/* 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; }