/* Evaluates functions in prefix form */
float PrefunExpr::eval_prefun_expr ( int mesh_i, int mesh_j )
{
assert ( func_ptr );
float * arg_list = new float[this->num_args];
assert(arg_list);
#ifdef EVAL_DEBUG_DOUBLE
DWRITE ( "fn[" );
#endif
//printf("numargs %d", num_args);
/* Evaluate each argument before calling the function itself */
for ( int i = 0; i < num_args; i++ )
{
arg_list[i] = expr_list[i]->eval_gen_expr ( mesh_i, mesh_j );
#ifdef EVAL_DEBUG_DOUBLE
if ( i < ( num_args - 1 ) )
DWRITE ( ", " );
#endif
//printf("numargs %x", arg_list[i]);
}
#ifdef EVAL_DEBUG_DOUBLE
DWRITE ( "]" );
#endif
/* Now we call the function, passing a list of
floats as its argument */
const float value = ( func_ptr ) ( arg_list );
delete[](arg_list);
return value;
}
float GenExpr::eval_gen_expr ( int mesh_i, int mesh_j )
{
float l;
assert ( item );
switch ( this->type )
{
case VAL_T:
return ( ( ValExpr* ) item )->eval_val_expr ( mesh_i, mesh_j );
case PREFUN_T:
l = ( ( PrefunExpr * ) item )->eval_prefun_expr ( mesh_i, mesh_j );
//if (EVAL_DEBUG) DWRITE( "eval_gen_expr: prefix function return value: %f\n", l);
return l;
case TREE_T:
return ( ( TreeExpr* ) ( item ) )->eval_tree_expr ( mesh_i, mesh_j );
default:
#ifdef EVAL_DEBUG
DWRITE ( "eval_gen_expr: general expression matched no cases!\n" );
#endif
return EVAL_ERROR;
}
}
int main(int argc, char* argv[])
{
int i, iter, niter, p[6][2], status, *mask;
float *buf, *buf2, *wht;
double rn, rnp, alpha, beta;
pid_t pid[6]={1,1,1,1,1,1};
off_t nm, nd, msiz, dsiz, pos;
size_t nbuf, mbuf, dbuf;
FILE *xfile, *Rfile, *gfile, *sfile, *Sfile;
char *x, *R, *g, *s, *S, *prog;
sf_file mod, dat, from, mwt, x0, known; /* input */
sf_file to, out; /* output */
extern int fseeko(FILE *stream, off_t offset, int whence);
extern off_t ftello (FILE *stream);
sf_init(argc,argv);
dat = sf_input("in");
mod = sf_input("mod");
if (SF_FLOAT != sf_gettype(mod) ||
SF_FLOAT != sf_gettype(dat))
sf_error("Need float type in mod and dat");
for (i=0; i < argc-1; i++) {
argv[i]=argv[i+1];
}
for (i=0; i < argc-1; i++) {
/* find the program to run */
if (NULL == strchr(argv[i],'=')) {
/* first one without the '=' */
prog = argv[0];
argv[0] = argv[i];
argv[i] = prog;
break;
}
}
argv[argc-1] = sf_charalloc(6);
snprintf(argv[argc-1],6,"adj=X");
if (!sf_getint("niter",&niter)) niter=1;
/* number of iterations */
Rfile = sf_tempfile(&R,"w+b");
xfile = sf_tempfile(&x,"w+b");
gfile = sf_tempfile(&g,"w+b");
sfile = sf_tempfile(&s,"w+b");
Sfile = sf_tempfile(&S,"w+b");
fclose(Rfile);
fclose(xfile);
fclose(gfile);
fclose(sfile);
fclose(Sfile);
nm = sf_filesize(mod);
nd = sf_filesize(dat);
/* I/O buffers */
nbuf = BUFSIZ/sizeof(float);
buf = sf_floatalloc(nbuf);
buf2 = sf_floatalloc(nbuf);
if (NULL != sf_getstring("mwt")) {
mwt = sf_input("mwt"); /* model weight */
wht = sf_floatalloc(nbuf);
} else {
mwt = NULL;
wht = NULL;
}
if (NULL != sf_getstring("known")) {
known = sf_input("known"); /* known model mask */
if (SF_INT != sf_gettype(known)) sf_error("Need int type in known");
mask = sf_intalloc(nbuf);
} else {
known = NULL;
mask = NULL;
}
if (NULL != sf_getstring("x0")) {
x0 = sf_input("x0"); /* initial model */
} else {
x0 = NULL;
}
for (i=0; i < 6; i++) { /* make six pipes */
if (pipe(p[i]) < 0) sf_error("pipe error:");
}
for (iter=0; iter < niter; iter++) {
for (i=0; i < 6; i++) { /* fork six children */
if ((pid[i] = fork()) < 0) sf_error("fork error:");
if (0 == pid[i]) break;
}
if (0 == pid[0]) {
/* feeds rr to p[0] */
close(p[0][0]);
close(STDOUT_FILENO);
DUP(p[0][1]);
to = sf_output("out");
if (0 == iter) {
xfile = fopen(x,"wb");
if (NULL == x0) {
for (i=0; i < nbuf; i++) { buf[i] = 0.0f; }
}
MLOOP( if (NULL != x0) sf_floatread(buf,mbuf,x0);
MWRITE(xfile); );
fclose(xfile);
Rfile = fopen(R,"wb");
DLOOP( sf_floatread(buf,dbuf,dat);
for (i=0; i < dbuf; i++) { buf[i] = -buf[i]; }
sf_floatwrite(buf,dbuf,to);
DWRITE (Rfile); );
/* Evaluates a value expression */
float ValExpr::eval_val_expr ( int mesh_i, int mesh_j )
{
/* Value is a constant, return the float value */
if ( type == CONSTANT_TERM_T )
{
#ifdef EVAL_DEBUG
DWRITE ( "%.4f", term.constant );
#endif
return ( term.constant );
}
/* Value is variable, dereference it */
if ( type == PARAM_TERM_T )
{
switch ( term.param->type )
{
case P_TYPE_BOOL:
#ifdef EVAL_DEBUG
DWRITE ( "(%s:%.4f)", term.param->name.c_str(), ( float ) ( * ( ( bool* ) ( term.param->engine_val ) ) ) );
#endif
return ( float ) ( * ( ( bool* ) ( term.param->engine_val ) ) );
case P_TYPE_INT:
#ifdef EVAL_DEBUG
DWRITE ( "(%s:%.4f)", term.param->name.c_str(), ( float ) ( * ( ( int* ) ( term.param->engine_val ) ) ) );
#endif
return ( float ) ( * ( ( int* ) ( term.param->engine_val ) ) );
case P_TYPE_DOUBLE:
if ( term.param->matrix_flag | ( term.param->flags & P_FLAG_ALWAYS_MATRIX ) )
{
/* Sanity check the matrix is there... */
assert ( term.param->matrix != NULL );
/// @slow boolean check could be expensive in this critical (and common) step of evaluation
if ( mesh_i >= 0 )
{
if ( mesh_j >= 0 )
{
return ( ( ( float** ) term.param->matrix ) [mesh_i][mesh_j] );
}
else
{
return ( ( ( float* ) term.param->matrix ) [mesh_i] );
}
}
//assert(mesh_i >=0);
}
//std::cout << term.param->name << ": " << (*((float*)term.param->engine_val)) << std::endl;
return * ( ( float* ) ( term.param->engine_val ) );
default:
return EVAL_ERROR;
}
}
/* Unknown type, return failure */
return PROJECTM_FAILURE;
}
/* Evaluates an expression tree */
float TreeExpr::eval_tree_expr ( int mesh_i, int mesh_j )
{
float left_arg, right_arg;
/* A leaf node, evaluate the general expression. If the expression is null as well, return zero */
if ( infix_op == NULL )
{
if ( gen_expr == NULL )
return 0;
else
return gen_expr->eval_gen_expr ( mesh_i, mesh_j );
}
/* Otherwise, this node is an infix operator. Evaluate
accordingly */
#ifdef EVAL_DEBUG
DWRITE ( "(" );
#endif
assert(left);
left_arg = left->eval_tree_expr ( mesh_i, mesh_j );
#ifdef EVAL_DEBUG
switch ( infix_op->type )
{
case INFIX_ADD:
DWRITE ( "+" );
break;
case INFIX_MINUS:
DWRITE ( "-" );
break;
case INFIX_MULT:
DWRITE ( "*" );
break;
case INFIX_MOD:
DWRITE ( "%%" );
break;
case INFIX_OR:
DWRITE ( "|" );
break;
case INFIX_AND:
DWRITE ( "&" );
break;
case INFIX_DIV:
DWRITE ( "/" );
break;
default:
DWRITE ( "?" );
}
#endif
assert(right);
right_arg = right->eval_tree_expr ( mesh_i, mesh_j );
#ifdef EVAL_DEBUG
DWRITE ( ")" );
#endif
#ifdef EVAL_DEBUG
DWRITE ( "\n" );
#endif
switch ( infix_op->type )
{
case INFIX_ADD:
return ( left_arg + right_arg );
case INFIX_MINUS:
return ( left_arg - right_arg );
case INFIX_MULT:
return ( left_arg * right_arg );
case INFIX_MOD:
if ( ( int ) right_arg == 0 )
{
#ifdef EVAL_DEBUG
DWRITE ( "eval_tree_expr: modulo zero!\n" );
#endif
return PROJECTM_DIV_BY_ZERO;
}
return ( ( int ) left_arg % ( int ) right_arg );
case INFIX_OR:
return ( ( int ) left_arg | ( int ) right_arg );
case INFIX_AND:
return ( ( int ) left_arg & ( int ) right_arg );
case INFIX_DIV:
if ( right_arg == 0 )
{
#ifdef EVAL_DEBUG
DWRITE ( "eval_tree_expr: division by zero!\n" );
#endif
return MAX_DOUBLE_SIZE;
}
return ( left_arg / right_arg );
default:
#ifdef EVAL_DEBUG
DWRITE ( "eval_tree_expr: unknown infix operator!\n" );
#endif
return EVAL_ERROR;
}
return EVAL_ERROR;
}
