SwitchingFunction::SwitchingFunction(const SwitchingFunction&sf): init(sf.init), type(sf.type), invr0(sf.invr0), d0(sf.d0), dmax(sf.dmax), nn(sf.nn), mm(sf.mm), a(sf.a), b(sf.b), c(sf.c), d(sf.d), lambda(sf.lambda), beta(sf.beta), ref(sf.ref), invr0_2(sf.invr0_2), dmax_2(sf.dmax_2), stretch(sf.stretch), shift(sf.shift), evaluator(NULL), evaluator_deriv(NULL) { #ifdef __PLUMED_HAS_MATHEVAL if(sf.evaluator) evaluator=evaluator_create(evaluator_get_string(sf.evaluator)); if(sf.evaluator_deriv) evaluator_deriv=evaluator_create(evaluator_get_string(sf.evaluator_deriv)); #endif }
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); } }
double newtonrap(double x0, double es, double *ea, int imax, int *iter, int tabla, char *buffer, char *buffer2) { double x1=x0; void *f, *f2; /* Evaluators for function and function derivative. */ /* Create evaluator for function. */ f = evaluator_create (buffer); f2 = evaluator_create (buffer2); assert (f); assert (f2); if(tabla == 1) { printf ("\n\n| i | Raiz | ea | f(xr) | \n"); printf ("______________________________________________________\n"); } *iter = 0; do{ x0 = x1; x1 = x0-(evaluator_evaluate_x(f,x0)/evaluator_evaluate_x(f2,x0)); *iter=*iter+1; if(x1!=0) { *ea=fabs((x1-x0)/x1)*100; } if ( tabla == 1 ) { printf ("| %2d | %12.8f | %12.8f | %12.8f |\n", *iter, x1, *ea, evaluator_evaluate_x(f,x1) ); } }while(es < *ea && *iter <= imax); evaluator_destroy(f); evaluator_destroy(f2); if ( tabla == 1 ) { printf ("\n\nLa Raiz es %6.4lf en %d iteraciones\n",x1,*iter); printf ("\n\nEl error relativo aproximado es %6.4lf\n",*ea); return 0; } else return x1; }
Polynomial::Polynomial( const std::string& e, const std::string& n, Object *p ) : Algorithm( n, p ) { char* f = strdup( e.c_str() ); m_e = evaluator_create( f ); free( f ); if( !m_e ) { throw std::invalid_argument( e + ": invalid polynomial" ); } parse_parameters(); }
void EVALOBJ::setExpression(char *expr) { int len = strlen(expr); if (expression != NULL) delete expression; expression = new char[len+1]; strcpy(expression, expr); setexp=TRUE; if (evaluator != NULL) evaluator_destroy(evaluator); evaluator = evaluator_create(expr); setexp=FALSE; if (evaluator == NULL) report_error("Unable to parse expression"); }
double pfijo(double x0, double es, double *ea, int imax, int *iter, int tabla, char *buffer) { double xr=x0, xrold; void *f; /* Evaluators for function and function derivative. */ /* Create evaluator for function. */ f = evaluator_create (buffer); assert (f); if(tabla == 1) { printf ("\n\n| i | Raiz | ea | f(xr) | \n"); printf ("______________________________________________________\n"); } *iter = 0; do{ xrold = xr; xr = evaluator_evaluate_x(f,xrold); *iter=*iter+1; if(xr!=0) { *ea=fabs((xr-xrold)/xr)*100; } if ( tabla == 1 ) { printf ("| %2d | %12.8f | %12.8f | %12.8f |\n", *iter, xr, *ea, evaluator_evaluate_x(f,xr) ); } }while(es < *ea && *iter <= imax); evaluator_destroy(f); if ( tabla == 1 ) { printf ("\n\nLa Raiz es %6.4lf en %d iteraciones\n",xr,*iter); printf ("\n\nEl error relativo aproximado es %6.4lf\n",*ea); return 0; } else return xr; }
/* TODO - Revisar que la formula sea correcta: * No tenga caracteres diferentes a una constante permitida y x. * Revisar que la formula tenga sentido para libmatheval... si no es el caso, explotar! */ void gs_function_plot_set_formula (GsFunctionPlot *plot, const gchar *formula) { g_return_if_fail (GS_IS_FUNCTION_PLOT (plot)); void *f = evaluator_create ((char *) formula); g_assert (f != NULL); /* if (f == NULL) { return FALSE; }*/ if (plot->priv->matheval_c != NULL) { evaluator_destroy (plot->priv->matheval_c); } plot->priv->matheval_c = f; g_signal_emit_by_name (G_OBJECT (plot), "plot-changed"); }
/* lcpi_parse_file */ int lcpi_parse_file(const char *file) { char buffer[BUFFER_SIZE]; FILE *lcpi_FP = NULL; lcpi_t *lcpi = NULL; int line = 0; OUTPUT_VERBOSE((4, "%s", _BLUE("Loading LCPI metrics"))); if (NULL == (lcpi_FP = fopen(file, "r"))) { OUTPUT(("%s (%s)", _ERROR("Error: unable to open LCPI file"), file)); return PERFEXPERT_ERROR; } bzero(buffer, BUFFER_SIZE); while (NULL != fgets(buffer, BUFFER_SIZE - 1, lcpi_FP)) { char *token = NULL; line++; /* Ignore comments and blank lines */ if ((0 == strncmp("#", buffer, 1)) || (strspn(buffer, " \t\r\n") == strlen(buffer))) { continue; } /* Remove the end \n character */ buffer[strlen(buffer) - 1] = '\0'; /* Replace some characters just to provide a safe expression */ perfexpert_string_replace_char(buffer, ':', '_'); /* Allocate and set LCPI data */ PERFEXPERT_ALLOC(lcpi_t, lcpi, sizeof(lcpi_t)); lcpi->value = 0.0; token = strtok(buffer, "="); PERFEXPERT_ALLOC(char, lcpi->name, strlen(token) + 1); strcpy(lcpi->name, perfexpert_string_remove_char(token, ' ')); strcpy(lcpi->name_md5, perfexpert_md5_string(lcpi->name)); token = strtok(NULL, "="); lcpi->expression = evaluator_create(token); if (NULL == lcpi->expression) { OUTPUT(("%s (%s)", _ERROR("Error: invalid expression at line"), line)); return PERFEXPERT_ERROR; } /* Add LCPI to global hash of LCPIs */ perfexpert_hash_add_str(globals.lcpi_by_name, name_md5, lcpi); OUTPUT_VERBOSE((7, " [%s]=[%s] (%s)", lcpi->name, evaluator_get_string(lcpi->expression), lcpi->name_md5)); } OUTPUT_VERBOSE((4, " (%d) %s", perfexpert_hash_count_str(globals.lcpi_by_name), _MAGENTA("LCPI metric(s) found"))); return PERFEXPERT_SUCCESS; }
/*! \brief convert_before_download() converts the value passed using the conversions bound to the widget \param widget (GtkWidget *) widget to extract the conversion info from \param value (gfloat *) the "real world" value from the tuning gui before translation to MS-units \returns the integere ms-units form after conversion */ G_MODULE_EXPORT gint convert_before_download(GtkWidget *widget, gfloat value) { static GStaticMutex mutex = G_STATIC_MUTEX_INIT; gint return_value = 0; gint tmpi = 0; gchar * conv_expr = NULL; void *evaluator = NULL; DataSize size = MTX_U08; float lower = 0.0; float upper = 0.0; gfloat *multiplier = NULL; gfloat *adder = NULL; guint i = 0; GHashTable *mhash = NULL; GHashTable *ahash = NULL; gchar *key_list = NULL; gchar *mult_list = NULL; gchar *add_list = NULL; gchar **keys = NULL; gchar **mults = NULL; gchar **adds = NULL; gint table_num = 0; gchar *tmpbuf = NULL; gchar * source_key = NULL; gchar * hash_key = NULL; gint *algorithm = NULL; GHashTable *sources_hash = NULL; sources_hash = DATA_GET(global_data,"sources_hash"); algorithm = DATA_GET(global_data,"algorithm"); g_static_mutex_lock(&mutex); if (!OBJ_GET(widget,"size")) printf(__FILE__"%s %s\n",_(": convert_before_download, FATAL ERROR, size undefined for widget %s "),glade_get_widget_name(widget)); size = (DataSize)OBJ_GET(widget,"size"); if (OBJ_GET(widget,"raw_lower")) lower = (gfloat)strtol(OBJ_GET(widget,"raw_lower"),NULL,10); else lower = (gfloat)get_extreme_from_size(size,LOWER); if (OBJ_GET(widget,"raw_upper")) upper = (gfloat)strtol(OBJ_GET(widget,"raw_upper"),NULL,10); else upper = (gfloat)get_extreme_from_size(size,UPPER); /* MULTI EXPRESSION ONLY! */ if (OBJ_GET(widget,"multi_expr_keys")) { if ((!OBJ_GET(widget,"mhash")) && (!OBJ_GET(widget,"ahash"))) { mhash = g_hash_table_new_full(g_str_hash,g_str_equal,g_free,g_free); ahash = g_hash_table_new_full(g_str_hash,g_str_equal,g_free,g_free); key_list = OBJ_GET(widget,"multi_expr_keys"); mult_list = OBJ_GET(widget,"fromecu_mults"); add_list = OBJ_GET(widget,"fromecu_addds"); keys = g_strsplit(key_list,",",-1); mults = g_strsplit(mult_list,",",-1); adds = g_strsplit(add_list,",",-1); for (i=0;i<MIN(g_strv_length(keys),g_strv_length(mults));i++) { multiplier = g_new0(gfloat, 1); *multiplier = (gfloat)g_strtod(mults[i],NULL); g_hash_table_insert(mhash,g_strdup(keys[i]),multiplier); adder = g_new0(gfloat, 1); *adder = (gfloat)g_strtod(adds[i],NULL); g_hash_table_insert(ahash,g_strdup(keys[i]),adder); } g_strfreev(keys); g_strfreev(mults); g_strfreev(adds); OBJ_SET_FULL(widget,"mhash",mhash,g_hash_table_destroy); OBJ_SET_FULL(widget,"ahash",ahash,g_hash_table_destroy); } mhash = OBJ_GET(widget,"mhash"); ahash = OBJ_GET(widget,"ahash"); source_key = OBJ_GET(widget,"source_key"); if (!source_key) printf(_("big problem, source key is undefined!!\n")); hash_key = (gchar *)g_hash_table_lookup(sources_hash,source_key); tmpbuf = (gchar *)OBJ_GET(widget,"table_num"); if (tmpbuf) table_num = (GINT)strtol(tmpbuf,NULL,10); if (table_num == -1) /* Not a table */ { if (!hash_key) { multiplier = g_hash_table_lookup(mhash,"DEFAULT"); adder = g_hash_table_lookup(ahash,"DEFAULT"); } else { multiplier = g_hash_table_lookup(mhash,(gchar *)hash_key); adder = g_hash_table_lookup(ahash,(gchar *)hash_key); } } else /* This is a 3d table */ { switch (algorithm[table_num]) { case SPEED_DENSITY: if (!hash_key) { multiplier = g_hash_table_lookup(mhash,"DEFAULT"); adder = g_hash_table_lookup(ahash,"DEFAULT"); } else { multiplier = g_hash_table_lookup(mhash,hash_key); adder = g_hash_table_lookup(ahash,hash_key); } break; case ALPHA_N: multiplier = g_hash_table_lookup(mhash,"DEFAULT"); adder = g_hash_table_lookup(ahash,"DEFAULT"); break; case MAF: multiplier = g_hash_table_lookup(mhash,"AFM_VOLTS"); adder = g_hash_table_lookup(ahash,"AFM_VOLTS"); break; } } /* Reverse calc due to this being TO the ecu */ if ((multiplier) && (adder)) return_value = (GINT)((value - (*adder))/(*multiplier)); else if (multiplier) return_value = (GINT)(value/(*multiplier)); else return_value = (GINT)value; } else /* NON Multi Expression */ { conv_expr = (gchar *)OBJ_GET(widget,"toecu_conv_expr"); /* Expression is NOT multi expression but has more complex math*/ if (conv_expr) { evaluator = (void *)OBJ_GET(widget,"dl_evaluator"); if (!evaluator) { evaluator = evaluator_create(conv_expr); assert(evaluator); OBJ_SET_FULL(widget,"dl_evaluator",(gpointer)evaluator,evaluator_destroy); } return_value = (GINT)evaluator_evaluate_x(evaluator,value); } else { multiplier = (gfloat *)OBJ_GET(widget,"fromecu_mult"); adder = (gfloat *)OBJ_GET(widget,"fromecu_add"); /* Handle all cases of with or without multiplier/adder*/ if ((multiplier) && (adder)) return_value = (GINT)((value - (*adder))/(*multiplier)); else if (multiplier) return_value = (GINT)(value/(*multiplier)); else return_value = (GINT)value; } } dbg_func(CONVERSIONS,g_strdup_printf(__FILE__": convert_before_dl():\n\t widget %s raw %.2f, sent %i\n",glade_get_widget_name(widget),value,return_value)); if (return_value > upper) { dbg_func(CONVERSIONS|CRITICAL,g_strdup_printf(__FILE__": convert_before_download()\n\t WARNING value clamped at %f (%f <- %f -> %f)!!\n",upper,lower,value,upper)); return_value = upper; } if (return_value < lower) { dbg_func(CONVERSIONS|CRITICAL,g_strdup_printf(__FILE__": convert_before_download()\n\t WARNING value clamped at %f (%f <- %f -> %f)!!\n",lower,lower,value,upper)); return_value = lower; } tmpi = return_value; if (OBJ_GET(widget,"lookuptable")) return_value = (GINT)reverse_lookup_obj(G_OBJECT(widget),tmpi); g_static_mutex_unlock(&mutex); return (return_value); }
/*! \brief convert_after_upload() converts the ms-units data to the real world units for display on the GUI \param widget (GtkWidget *) to extract the conversion info from to perform the necessary math \returns the real world value for the GUI */ G_MODULE_EXPORT gfloat convert_after_upload(GtkWidget * widget) { static GStaticMutex mutex = G_STATIC_MUTEX_INIT; static gint (*get_ecu_data_f)(gpointer); static void (*send_to_ecu_f)(gpointer, gint, gboolean) = NULL; gfloat return_value = 0.0; gchar * conv_expr = NULL; void *evaluator = NULL; gint tmpi = 0; DataSize size = 0; gfloat lower = 0.0; gfloat upper = 0.0; gboolean fromecu_complex = FALSE; guint i = 0; gint table_num = -1; GHashTable *mhash = NULL; GHashTable *ahash = NULL; gchar *key_list = NULL; gchar *mult_list = NULL; gchar *add_list = NULL; gchar **keys = NULL; gchar **mults = NULL; gchar **adds = NULL; gchar * tmpbuf = NULL; gchar * source_key = NULL; gchar * hash_key = NULL; gfloat *multiplier = NULL; gfloat *adder = NULL; gint *algorithm = NULL; GHashTable *sources_hash = NULL; extern gconstpointer *global_data; if (!get_ecu_data_f) get_symbol("get_ecu_data",(void *)&get_ecu_data_f); if (!send_to_ecu_f) get_symbol("send_to_ecu",(void *)&send_to_ecu_f); g_return_val_if_fail(get_ecu_data_f,0.0); g_return_val_if_fail(send_to_ecu_f,0.0); g_static_mutex_lock(&mutex); size = (DataSize)OBJ_GET(widget,"size"); if (size == 0) { printf(_("BIG PROBLEM, size undefined! widget %s, default to U08 \n"),(gchar *)glade_get_widget_name(widget)); size = MTX_U08; } if (OBJ_GET(widget,"raw_lower")) lower = (gfloat)strtol(OBJ_GET(widget,"raw_lower"),NULL,10); else lower = (gfloat)get_extreme_from_size(size,LOWER); if (OBJ_GET(widget,"raw_upper")) upper = (gfloat)strtol(OBJ_GET(widget,"raw_upper"),NULL,10); else upper = (gfloat)get_extreme_from_size(size,UPPER); fromecu_complex = (GBOOLEAN)OBJ_GET(widget,"fromecu_complex"); if (fromecu_complex) { g_static_mutex_unlock(&mutex); /*printf("Complex upload conversion for widget at page %i, offset %i, name %s\n",(GINT)OBJ_GET(widget,"page"),(GINT)OBJ_GET(widget,"offset"),glade_get_widget_name(widget)); */ return handle_complex_expr_obj(G_OBJECT(widget),NULL,UPLOAD); } if (OBJ_GET(widget,"lookuptable")) tmpi = lookup_data_obj(G_OBJECT(widget),get_ecu_data_f(widget)); else tmpi = get_ecu_data_f(widget); if (tmpi < lower) { dbg_func(CONVERSIONS|CRITICAL,g_strdup_printf(__FILE__": convert_after_upload()\n\t WARNING RAW value out of range for widget %s, clamped at %.1f (%.1f <- %i -> %.1f), updating ECU with valid value within limits!!\n",(gchar *)glade_get_widget_name(widget),lower,lower,tmpi,upper)); tmpi = lower; send_to_ecu_f(widget,tmpi,TRUE); } if (tmpi > upper) { dbg_func(CONVERSIONS|CRITICAL,g_strdup_printf(__FILE__": convert_after_upload()\n\t WARNING RAW value out of range for widget %s, clamped at %.1f (%.1f <- %i -> %.1f), updating ECU with valid value within limits!!\n",(gchar *)glade_get_widget_name(widget),lower,lower,tmpi,upper)); tmpi = upper; send_to_ecu_f(widget,tmpi,TRUE); } /* MULTI EXPRESSION ONLY! */ if (OBJ_GET(widget,"multi_expr_keys")) { sources_hash = DATA_GET(global_data,"sources_hash"); if ((!OBJ_GET(widget,"mhash")) && (!OBJ_GET(widget,"ahash"))) { mhash = g_hash_table_new_full(g_str_hash,g_str_equal,g_free,g_free); ahash = g_hash_table_new_full(g_str_hash,g_str_equal,g_free,g_free); key_list = OBJ_GET(widget,"multi_expr_keys"); mult_list = OBJ_GET(widget,"fromecu_mults"); add_list = OBJ_GET(widget,"fromecu_adds"); if (!mult_list) printf("BUG, widget %s is multi_expression but doesn't have fromecu_mults defined!\n",glade_get_widget_name(widget)); if (!add_list) printf("BUG, widget %s is multi_expression but doesn't have fromecu_adds defined!\n",glade_get_widget_name(widget)); keys = g_strsplit(key_list,",",-1); mults = g_strsplit(mult_list,",",-1); adds = g_strsplit(add_list,",",-1); for (i=0;i<MIN(g_strv_length(keys),g_strv_length(mults));i++) { multiplier = g_new0(gfloat, 1); *multiplier = (gfloat)g_strtod(mults[i],NULL); g_hash_table_insert(mhash,g_strdup(keys[i]),multiplier); adder = g_new0(gfloat, 1); *adder = (gfloat)g_strtod(adds[i],NULL); g_hash_table_insert(ahash,g_strdup(keys[i]),adder); } g_strfreev(keys); g_strfreev(mults); g_strfreev(adds); OBJ_SET_FULL(widget,"mhash",mhash,g_hash_table_destroy); OBJ_SET_FULL(widget,"ahash",ahash,g_hash_table_destroy); } mhash = OBJ_GET(widget,"mhash"); ahash = OBJ_GET(widget,"ahash"); source_key = OBJ_GET(widget,"source_key"); if (!source_key) printf(_("big problem, source key is undefined!!\n")); hash_key = (gchar *)g_hash_table_lookup(sources_hash,source_key); tmpbuf = (gchar *)OBJ_GET(widget,"table_num"); if (tmpbuf) table_num = (GINT)strtol(tmpbuf,NULL,10); if (table_num == -1) { if (!hash_key) { multiplier = g_hash_table_lookup(mhash,"DEFAULT"); adder = g_hash_table_lookup(ahash,"DEFAULT"); } else { multiplier = g_hash_table_lookup(mhash,(gchar *)hash_key); adder = g_hash_table_lookup(ahash,(gchar *)hash_key); } } else { algorithm = DATA_GET(global_data,"algorithm"); switch (algorithm[table_num]) { case SPEED_DENSITY: if (!hash_key) { multiplier = g_hash_table_lookup(mhash,"DEFAULT"); adder = g_hash_table_lookup(ahash,"DEFAULT"); } else { multiplier = g_hash_table_lookup(mhash,hash_key); adder = g_hash_table_lookup(ahash,hash_key); } break; case ALPHA_N: multiplier = g_hash_table_lookup(mhash,"DEFAULT"); adder = g_hash_table_lookup(ahash,"DEFAULT"); break; case MAF: multiplier = g_hash_table_lookup(mhash,"AFM_VOLTS"); adder = g_hash_table_lookup(ahash,"AFM_VOLTS"); break; } } if ((multiplier) && (adder)) return_value = (((gfloat)tmpi * (*multiplier)) + (*adder)); else if (multiplier) return_value = (gfloat)tmpi * (*multiplier); else return_value = (gfloat)tmpi; } else { conv_expr = (gchar *)OBJ_GET(widget,"fromecu_conv_expr"); if (conv_expr) { evaluator = (void *)OBJ_GET(widget,"ul_evaluator"); if (!evaluator) { evaluator = evaluator_create(conv_expr); assert(evaluator); OBJ_SET_FULL(widget,"ul_evaluator",(gpointer)evaluator,evaluator_destroy); } return_value = evaluator_evaluate_x(evaluator,tmpi); } else { multiplier = OBJ_GET(widget,"fromecu_mult"); adder = OBJ_GET(widget,"fromecu_add"); if ((multiplier) && (adder)) return_value = (((gfloat)tmpi * (*multiplier)) + (*adder)); else if (multiplier) return_value = (gfloat)tmpi * (*multiplier); else return_value = (gfloat)tmpi; /*dbg_func(CONVERSIONS,g_strdup_printf(__FILE__": convert_after_ul():\n\tNo/Fast CONVERSION defined for widget %s, value %f\n",(gchar *)glade_get_widget_name(widget), return_value));*/ } } // dbg_func(CONVERSIONS,g_strdup_printf(__FILE__": convert_after_ul()\n\t page %i,offset %i, raw %i, val %f\n",page,offset,tmpi,return_value)); g_static_mutex_unlock(&mutex); return (return_value); }
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; } }