/* Helper to replace a connection's expression only if the given string
* parses successfully. Returns 0 on success, non-zero on error. */
static int replace_expression_string(mapper_connection c,
const char *expr_str,
int *input_history_size,
int *output_history_size)
{
mapper_expr expr = mapper_expr_new_from_string(
expr_str, c->props.src_type, c->props.dest_type,
c->props.src_length, c->props.dest_length);
if (!expr)
return 1;
*input_history_size = mapper_expr_input_history_size(expr);
*output_history_size = mapper_expr_output_history_size(expr);
if (c->expr)
mapper_expr_free(c->expr);
c->expr = expr;
if (c->props.expression == expr_str)
return 0;
int len = strlen(expr_str);
if (!c->props.expression || len > strlen(c->props.expression))
c->props.expression = realloc(c->props.expression, len+1);
/* Using strncpy() here causes memory profiling errors due to possible
* overlapping memory (e.g. expr_str == c->props.expression). */
memcpy(c->props.expression, expr_str, len);
c->props.expression[len] = '\0';
return 0;
}
int test2()
{
const char str[] = "y=26*2/2+x*30/(20*1)";
mapper_expr e = mapper_expr_new_from_string(str, 0, 0, 1);
printf("\nParsing %s\n", str);
if (!e) { printf("Test FAILED.\n"); return 1; }
#ifdef DEBUG
printexpr("Parser returned: ", e);
#endif
printf("\n");
int inp, outp;
inp = 3;
mapper_expr_evaluate(e, &inp, &outp);
printf("Evaluate with x=%d: %d (expected: %d)\n",
inp, outp,
26*2/2+inp*30/(20*1));
inp = 321;
mapper_expr_evaluate(e, &inp, &outp);
printf("Evaluate with x=%d: %d (expected: %d)\n",
inp, outp,
26*2/2+inp*30/(20*1));
mapper_expr_free(e);
return 0;
}
int main()
{
const char str[] = "y=26*2/2+log10(pi)+2.*pow(2,1*(3+7*.1)*1.1+x{0}[0])*3*4+cos(2.)";
//const char str[] = "y=x?1:2";
int input_history_size, output_history_size;
mapper_expr e = mapper_expr_new_from_string(str, 'f', 'f', 1, 1,
&input_history_size,
&output_history_size);
printf("Parsing %s\n", str);
if (!e) { printf("Test FAILED.\n"); return 1; }
#ifdef DEBUG
printexpr("Parser returned: ", e);
#endif
printf("\n");
float inp = 3.0, outp;
// create signal_history structures
mapper_signal_history_t inh, outh;
inh.type = 'f';
inh.size = 1;
inh.length = 1;
inh.value = &inp;
inh.timetag = calloc(1, sizeof(mapper_timetag_t));
inh.position = 0;
outh.type = 'f';
outh.size = 1;
outh.length = 1;
outh.value = &outp;
outh.timetag = calloc(1, sizeof(mapper_timetag_t));
outh.position = -1;
int iterations = 1000000;
int results = 0;
double then = get_current_time();
printf("Calculate expression %i times... ", iterations);
while (iterations--) {
results += mapper_expr_evaluate(e, &inh, &outh);
}
double now = get_current_time();
printf("%f seconds.\n", now-then);
if (results) {
printf("Evaluate with x=%f: %f (expected: %f)\n",
inp, outp,
26*2/2+log10f(M_PI)+2.f*powf(2,1*(3+7*.1f)*1.1f+inp)*3*4+cosf(2.0f));
}
else
printf("NO results.\n");
mapper_expr_free(e);
free(inh.timetag);
free(outh.timetag);
return 0;
}
/* Helper to replace a connection's expression only if the given string
* parses successfully. Returns 0 on success, non-zero on error. */
static int replace_expression_string(mapper_connection c,
mapper_signal s,
const char *expr_str)
{
mapper_expr expr = mapper_expr_new_from_string(
expr_str, s->props.type=='f', c->props.dest_type=='f',
s->props.length);
if (!expr)
return 1;
if (c->expr)
mapper_expr_free(c->expr);
c->expr = expr;
int len = strlen(expr_str)+1;
if (!c->props.expression || len > strlen(c->props.expression))
c->props.expression = realloc(c->props.expression, len);
strncpy(c->props.expression, expr_str, len);
return 0;
}
int test1()
{
const char str[] = "y=26*2/2+log10(pi)+2.*pow(2,1*(3+7*.1)*1.1+x{-6*2+12})*3*4+cos(2.)";
mapper_expr e = mapper_expr_new_from_string(str, 1, 1, 1);
printf("Parsing %s\n", str);
if (!e) { printf("Test FAILED.\n"); return 1; }
#ifdef DEBUG
printexpr("Parser returned: ", e);
#endif
printf("\n");
float inp, outp;
inp = 3.0;
mapper_expr_evaluate(e, &inp, &outp);
printf("Evaluate with x=%f: %f (expected: %f)\n",
inp, outp,
26*2/2+log10f(M_PI)+2.f*powf(2,1*(3+7*.1f)*1.1f+inp)*3*4+cosf(2.0f));
mapper_expr_free(e);
return 0;
}
int parse_and_eval(int expectation)
{
// clear output arrays
int i;
for (i = 0; i < DEST_ARRAY_LEN; i++) {
dest_int[i] = 0;
dest_float[i] = 0.0f;
dest_double[i] = 0.0;
}
eprintf("***************** Expression %d *****************\n",
expression_count++);
eprintf("Parsing string '%s'\n", str);
e = mapper_expr_new_from_string(str, num_sources, src_types, src_lengths,
outh.type, outh.length);
if (!e) {
eprintf("Parser FAILED.\n");
goto fail;
}
for (i = 0; i < num_sources; i++) {
inh[i].size = mapper_expr_input_history_size(e, i);
}
outh.size = mapper_expr_output_history_size(e);
if (mapper_expr_num_variables(e) > MAX_VARS) {
eprintf("Maximum variables exceeded.\n");
goto fail;
}
// reallocate variable value histories
for (i = 0; i < e->num_variables; i++) {
eprintf("user_var[%d]: %p\n", i, &user_vars[i]);
mhist_realloc(&user_vars[i], e->variables[i].history_size,
sizeof(double), 0);
}
user_vars_p = user_vars;
#ifdef DEBUG
if (verbose) {
char str[128];
snprintf(str, 128, "Parser returned %d tokens:", e->length);
printexpr(str, e);
}
#endif
token_count += e->length;
eprintf("Try evaluation once... ");
if (!mapper_expr_evaluate(e, inh_p, &user_vars_p, &outh, &tt_in, typestring)) {
eprintf("FAILED.\n");
goto fail;
}
eprintf("OK\n");
then = current_time();
eprintf("Calculate expression %i times... ", iterations);
i = iterations-1;
while (i--) {
mapper_expr_evaluate(e, inh_p, &user_vars_p, &outh, &tt_in, typestring);
}
now = current_time();
eprintf("%g seconds.\n", now-then);
total_elapsed_time += now-then;
if (verbose) {
printf("Got: ");
print_value(typestring, outh.length, outh.value, outh.position);
printf(" \n");
}
else
printf(".");
mapper_expr_free(e);
return expectation != EXPECT_SUCCESS;
fail:
return expectation != EXPECT_FAILURE;
}