void rb_monitor_get_op_variables(const rb_monitor_t *monitor, char ***vars, size_t *vars_size) { void *evaluator = NULL; (*vars) = NULL; *vars_size = 0; struct { char **vars; int count; } all_vars; if (monitor->type != RB_MONITOR_T__OP) { goto no_deps; } evaluator = evaluator_create((char *)monitor->cmd_arg); if (NULL == evaluator) { rdlog(LOG_ERR, "Couldn't create an evaluator from %s", monitor->cmd_arg); goto no_deps; } evaluator_get_variables(evaluator, &all_vars.vars, &all_vars.count); (*vars) = malloc((size_t)all_vars.count * sizeof((*vars)[0])); if (*vars == NULL) { rdlog(LOG_CRIT, "Couldn't allocate memory for %d vars", all_vars.count); goto no_deps; } for (int i = 0; i < all_vars.count; ++i) { (*vars)[i] = strdup(all_vars.vars[i]); if (NULL == (*vars)[i]) { rdlog(LOG_ERR, "Couldn't strdup %s (OOM?)", all_vars.vars[i]); for (int j = 0; j < i; ++j) { free((*vars)[j]); (*vars)[j] = NULL; } goto no_deps; } } *vars_size = (size_t)all_vars.count; evaluator_destroy(evaluator); return; no_deps: if (*vars) { free(*vars); } *vars = NULL; *vars_size = 0; if (evaluator) { evaluator_destroy(evaluator); } }
void Polynomial::parse_parameters() { char** names; int i, count; evaluator_get_variables( m_e, &names, &count); for( i = 0; i < count; i++) addParameter( names[i] ); }
/* lcpi_compute */ int lcpi_compute(profile_t *profile) { lcpi_t *hotspot_lcpi = NULL, *lcpi = NULL; procedure_t *hotspot = NULL; double *values = NULL; char **names = NULL; int count = 0; OUTPUT_VERBOSE((4, " %s", _CYAN("Calculating LCPI metrics"))); /* For each hotspot in this profile... */ hotspot = (procedure_t *)perfexpert_list_get_first(&(profile->hotspots)); while ((perfexpert_list_item_t *)hotspot != &(profile->hotspots.sentinel)) { OUTPUT_VERBOSE((8, " [%d] %s", hotspot->id, _YELLOW(hotspot->name))); /* For each LCPI definition */ for (lcpi = globals.lcpi_by_name; lcpi != NULL; lcpi = lcpi->hh_str.next) { /* Copy LCPI definitions into this hotspot LCPI hash */ PERFEXPERT_ALLOC(lcpi_t, hotspot_lcpi, sizeof(lcpi_t)); strcpy(hotspot_lcpi->name_md5, lcpi->name_md5); hotspot_lcpi->name = lcpi->name; hotspot_lcpi->value = lcpi->value; hotspot_lcpi->expression = lcpi->expression; /* Get the list of variables and their values */ evaluator_get_variables(hotspot_lcpi->expression, &names, &count); if (0 < count) { int i = 0; PERFEXPERT_ALLOC(double, values, (sizeof(double*) * count)); for (i = 0; i < count; i++) { metric_t *metric = NULL; char key_md5[33]; strcpy(key_md5, perfexpert_md5_string(names[i])); perfexpert_hash_find_str(hotspot->metrics_by_name, (char *)&key_md5, metric); if (NULL == metric) { perfexpert_hash_find_str(globals.machine_by_name, (char *)&key_md5, metric); if (NULL == metric) { values[i] = 0.0; } else { values[i] = metric->value; } } else { values[i] = metric->value; } } /* Evaluate the LCPI expression */ hotspot_lcpi->value = evaluator_evaluate( hotspot_lcpi->expression, count, names, values); PERFEXPERT_DEALLOC(values); } /* Add the LCPI to the hotspot's list of LCPIs */ perfexpert_hash_add_str(hotspot->lcpi_by_name, name_md5, hotspot_lcpi); OUTPUT_VERBOSE((10, " %s=[%g]", hotspot_lcpi->name, hotspot_lcpi->value)); } /* Move on */ hotspot = (procedure_t *)perfexpert_list_get_next(hotspot); }
char *oph_predicate2(UDF_INIT * initid, UDF_ARGS * args, char *result, unsigned long *length, char *is_null, char *error) { oph_string measure; char *buffer; char **names; int count; oph_predicate2_param *param; int i = 0; if (core_set_type(&(measure), args->args[0], &(args->lengths[0]))) { pmesg(1, __FILE__, __LINE__, "Type not recognized\n"); *length = 0; *is_null = 0; *error = 1; return NULL; } measure.content = args->args[2]; measure.length = &(args->lengths[2]); measure.missingvalue = NULL; core_set_elemsize(&(measure)); if (core_set_numelem(&(measure))) { pmesg(1, __FILE__, __LINE__, "Error on counting elements\n"); *length = 0; *is_null = 0; *error = 1; return NULL; } if (!initid->ptr) { initid->ptr = (char *) malloc(sizeof(oph_predicate2_param)); if (!initid->ptr) { pmesg(1, __FILE__, __LINE__, "Error allocating result string\n"); *length = 0; *is_null = 0; *error = 1; return NULL; } param = (oph_predicate2_param *) initid->ptr; for (i = 0; i < 4; ++i) param->f[i] = NULL; param->occurrence = 0; // ALL buffer = (char *) malloc(1 + args->lengths[3]); strncpy(buffer, args->args[3], args->lengths[3]); buffer[args->lengths[3]] = '\0'; pthread_rwlock_wrlock(&lock); param->f[1] = evaluator_create(buffer); pthread_rwlock_unlock(&lock); free(buffer); if (!param->f[1]) { pmesg(1, __FILE__, __LINE__, "Error allocating evaluator\n"); *length = 0; *is_null = 0; *error = 1; return NULL; } evaluator_get_variables(param->f[1], &names, &count); if (count > 1) { pmesg(1, __FILE__, __LINE__, "Too variables in expression\n"); *length = 0; *is_null = 0; *error = 1; return NULL; } // Comparison operator if (core_set_comp(¶m->op, args->args[4], &(args->lengths[4]))) { pmesg(1, __FILE__, __LINE__, "Comparison operator not recognized\n"); *length = 0; *is_null = 0; *error = 1; return NULL; } if (args->args[5] && args->lengths[5]) { buffer = (char *) malloc(1 + args->lengths[5]); core_strncpy(buffer, args->args[5], &(args->lengths[5])); if (!strcasecmp(buffer, "nan")) sprintf(buffer, "0/0"); } else buffer = strdup("0/0"); pthread_rwlock_wrlock(&lock); param->f[2] = evaluator_create(buffer); pthread_rwlock_unlock(&lock); free(buffer); if (!param->f[2]) { pmesg(1, __FILE__, __LINE__, "Error allocating evaluator\n"); *length = 0; *is_null = 0; *error = 1; return NULL; } evaluator_get_variables(param->f[2], &names, &count); if (count > 1) { pmesg(1, __FILE__, __LINE__, "Too variables in expression\n"); *length = 0; *is_null = 0; *error = 1; return NULL; } if (args->args[6] && args->lengths[6]) { buffer = (char *) malloc(1 + args->lengths[6]); core_strncpy(buffer, args->args[6], &(args->lengths[6])); if (!strcasecmp(buffer, "nan")) sprintf(buffer, "0/0"); } else buffer = strdup("0/0"); pthread_rwlock_wrlock(&lock); param->f[3] = evaluator_create(buffer); pthread_rwlock_unlock(&lock); free(buffer); if (!param->f[3]) { pmesg(1, __FILE__, __LINE__, "Error allocating evaluator\n"); *length = 0; *is_null = 0; *error = 1; return NULL; } evaluator_get_variables(param->f[3], &names, &count); if (count > 1) { pmesg(1, __FILE__, __LINE__, "Too variables in expression\n"); *length = 0; *is_null = 0; *error = 1; return NULL; } oph_string output_array; core_set_type(&output_array, args->args[1], &(args->lengths[1])); if (!output_array.type) { pmesg(1, __FILE__, __LINE__, "Unable to recognize measures type\n"); *length = 0; *is_null = 0; *error = 1; return NULL; } if (core_set_elemsize(&output_array)) { pmesg(1, __FILE__, __LINE__, "Unable to recognize measures type\n"); *length = 0; *is_null = 0; *error = 1; return NULL; } param->result_type = output_array.type; param->result_elemsize = output_array.elemsize; param->length = output_array.elemsize * measure.numelem; param->f[0] = malloc(param->length); if (!param->f[0]) { pmesg(1, __FILE__, __LINE__, "Error allocating result string\n"); *length = 0; *is_null = 0; *error = 1; return NULL; } if (args->arg_count > 7) { buffer = (char *) malloc(1 + args->lengths[7]); core_strncpy(buffer, args->args[7], &(args->lengths[7])); if (strcasecmp(buffer, OPH_PREDICATE2_ALL_OCCURRENCE)) { if (!strcasecmp(buffer, OPH_PREDICATE2_FIRST_OCCURRENCE) || !strcasecmp(buffer, OPH_PREDICATE2_BEGIN_OCCURRENCE)) param->occurrence = 1; else if (!strcasecmp(buffer, OPH_PREDICATE2_LAST_OCCURRENCE) || !strcasecmp(buffer, OPH_PREDICATE2_END_OCCURRENCE)) param->occurrence = -1; else { if (args->arg_type[7] == STRING_RESULT) param->occurrence = (long) strtol(buffer, NULL, 10); else param->occurrence = *((long long *) args->args[7]); if (param->occurrence < 1) { free(buffer); pmesg(1, __FILE__, __LINE__, "Unable to read occurrence\n"); *length = 0; *is_null = 0; *error = 1; return NULL; } } } free(buffer); } } else param = (oph_predicate2_param *) initid->ptr; i = core_oph_predicate2(&measure, initid->ptr); if (i) { pmesg(1, __FILE__, __LINE__, "Unable to compute result\n"); *length = 0; *is_null = 0; *error = 1; return NULL; } *length = param->length; *error = 0; *is_null = 0; return (char *) param->f[0]; }
char *me_change_string(char *string, int opt, me_t * me) { void *f = NULL, *f_prim = NULL; char *sep_ptr; char *str = NULL; char **names = NULL; int count = 0; char *f_prim_str = NULL; char *vars_str = NULL; double res = 0, res_prim = 0; debug(NULL, "me_change_string: Entered: %s\n", string); if (!me || !string) return NULL; sep_ptr = str_find_sep(string); if (sep_ptr) string = sep_ptr; if (!strlen(string)) return NULL; f = evaluator_create(string); if (!f) return NULL; evaluator_get_variables(f, &names, &count); if (!names) goto cleanup; vars_str = array_to_str((void **)names, count, (char *(*)(void *))strdup); if (!vars_str) goto cleanup; f_prim = evaluator_derivative_x(f); if (!f_prim) goto cleanup; f_prim_str = evaluator_get_string(f_prim); res = evaluator_evaluate_x_y_z(f, me->x, me->y, me->z); res_prim = evaluator_evaluate_x_y_z(f_prim, me->x, me->y, me->z); str = str_unite("f(x,y,z)=%f ... vars={%s} ::: f'(x)=%s=%f", res, vars_str, f_prim_str, res_prim); cleanup: if (f_prim) evaluator_destroy(f_prim); if (f) evaluator_destroy(f); if (vars_str) free(vars_str); return str; }
void SwitchingFunction::set(const std::string & definition,std::string& errormsg){ vector<string> data=Tools::getWords(definition); if( data.size()<1 ) errormsg="missing all input for switching function"; string name=data[0]; data.erase(data.begin()); invr0=0.0; invr0_2=0.0; d0=0.0; dmax=std::numeric_limits<double>::max(); dmax_2=std::numeric_limits<double>::max(); stretch=1.0; shift=0.0; init=true; bool present; present=Tools::findKeyword(data,"D_0"); if(present && !Tools::parse(data,"D_0",d0)) errormsg="could not parse D_0"; present=Tools::findKeyword(data,"D_MAX"); if(present && !Tools::parse(data,"D_MAX",dmax)) errormsg="could not parse D_MAX"; if(dmax<std::sqrt(std::numeric_limits<double>::max())) dmax_2=dmax*dmax; bool dostretch=false; Tools::parseFlag(data,"STRETCH",dostretch); // this is ignored now dostretch=true; bool dontstretch=false; Tools::parseFlag(data,"NOSTRETCH",dontstretch); // this is ignored now if(dontstretch) dostretch=false; double r0; if(name=="CUBIC"){ r0 = dmax - d0; } else { bool found_r0=Tools::parse(data,"R_0",r0); if(!found_r0) errormsg="R_0 is required"; } invr0=1.0/r0; invr0_2=invr0*invr0; if(name=="RATIONAL"){ type=rational; nn=6; mm=0; present=Tools::findKeyword(data,"NN"); if(present && !Tools::parse(data,"NN",nn)) errormsg="could not parse NN"; present=Tools::findKeyword(data,"MM"); if(present && !Tools::parse(data,"MM",mm)) errormsg="could not parse MM"; if(mm==0) mm=2*nn; } else if(name=="SMAP"){ type=smap; present=Tools::findKeyword(data,"A"); if(present && !Tools::parse(data,"A",a)) errormsg="could not parse A"; present=Tools::findKeyword(data,"B"); if(present && !Tools::parse(data,"B",b)) errormsg="could not parse B"; c=pow(2., static_cast<double>(a)/static_cast<double>(b) ) - 1; d = -static_cast<double>(b) / static_cast<double>(a); } else if(name=="Q") { type=nativeq; beta = 50.0; // nm-1 lambda = 1.8; // unitless present=Tools::findKeyword(data,"BETA"); if(present && !Tools::parse(data, "BETA", beta)) errormsg="could not parse BETA"; present=Tools::findKeyword(data,"LAMBDA"); if(present && !Tools::parse(data, "LAMBDA", lambda)) errormsg="could not parse LAMBDA"; bool found_ref=Tools::parse(data,"REF",ref); // nm if(!found_ref) errormsg="REF (reference disatance) is required for native Q"; } else if(name=="EXP") type=exponential; else if(name=="GAUSSIAN") type=gaussian; else if(name=="CUBIC") type=cubic; else if(name=="TANH") type=tanh; #ifdef __PLUMED_HAS_MATHEVAL else if(name=="MATHEVAL"){ type=matheval; std::string func; Tools::parse(data,"FUNC",func); evaluator=evaluator_create(const_cast<char*>(func.c_str())); char **check_names; int check_count; evaluator_get_variables(evaluator,&check_names,&check_count); if(check_count!=1){ errormsg="wrong number of arguments in MATHEVAL switching function"; return; } if(std::string(check_names[0])!="x"){ errormsg ="argument should be named 'x'"; return; } evaluator_deriv=evaluator_derivative(evaluator,const_cast<char*>("x")); } #endif else errormsg="cannot understand switching function type '"+name+"'"; if( !data.empty() ){ errormsg="found the following rogue keywords in switching function input : "; for(unsigned i=0;i<data.size();++i) errormsg = errormsg + data[i] + " "; } if(dostretch && dmax!=std::numeric_limits<double>::max()){ double dummy; double s0=calculate(0.0,dummy); double sd=calculate(dmax,dummy); stretch=1.0/(s0-sd); shift=-sd*stretch; } }