int calcMin(Jeu *jeu, int prof){ int i,j,tmp; int min = MAXEVAL; if(prof==0) return evalue(jeu); if(jeu->getFini()) return evalue(jeu); for(i=0;i<10; i++){ for(j=0;j<10;j++){ if(jeu->estVide(i,j)){ jeu->joue(i,j); tmp = calcMax(jeu, prof-1); if(tmp<min) { min = tmp; } annuleCoup(i,j); } } return min; } }
static double epow( EPNODE *ep ) { EPNODE *ep1 = ep->v.kid; double d; int lasterrno; lasterrno = errno; errno = 0; d = pow(evalue(ep1), evalue(ep1->sibling)); #ifdef isnan if (errno == 0) { if (isnan(d)) errno = EDOM; else if (isinf(d)) errno = ERANGE; } #endif if (errno == EDOM || errno == ERANGE) { wputs("Illegal power\n"); return(0.0); } errno = lasterrno; return(d); }
static double eadd( EPNODE *ep ) { EPNODE *ep1 = ep->v.kid; return(evalue(ep1) + evalue(ep1->sibling)); }
static double esubtr( EPNODE *ep ) { EPNODE *ep1 = ep->v.kid; return(evalue(ep1) - evalue(ep1->sibling)); }
static double emult( EPNODE *ep ) { EPNODE *ep1 = ep->v.kid; return(evalue(ep1) * evalue(ep1->sibling)); }
static void combine(void) /* combine pictures */ { EPNODE *coldef[3], *brtdef; COLOR *scanout; double d; register int i, j; /* check defined variables */ for (j = 0; j < 3; j++) { if (vardefined(vcolout[j])) coldef[j] = eparse(vcolout[j]); else coldef[j] = NULL; } if (vardefined(vbrtout)) brtdef = eparse(vbrtout); else brtdef = NULL; /* allocate scanline */ scanout = (COLOR *)emalloc(xres*sizeof(COLOR)); /* set input position */ yscan = ymax+MIDSCN; /* combine files */ for (ypos = yres-1; ypos >= 0; ypos--) { advance(); varset(vypos, '=', (double)ypos); for (xpos = 0; xpos < xres; xpos++) { xscan = (xpos+.5)*xmax/xres; varset(vxpos, '=', (double)xpos); eclock++; if (brtdef != NULL) { d = evalue(brtdef); if (d < 0.0) d = 0.0; setcolor(scanout[xpos], d, d, d); } else { for (j = 0; j < 3; j++) { if (coldef[j] != NULL) { d = evalue(coldef[j]); } else { d = 0.0; for (i = 0; i < nfiles; i++) d += colval(input[i].scan[MIDSCN][xscan],j); } if (d < 0.0) d = 0.0; colval(scanout[xpos],j) = d; } } } if (fwritescan(scanout, xres, stdout) < 0) { perror("write error"); quit(1); } } efree((char *)scanout); }
static double /* evaluate a variable */ dvalue(char *name, EPNODE *d) { EPNODE *ep1, *ep2; if (d == NULL || d->v.kid->type != SYM) { eputs(name); eputs(": undefined variable\n"); quit(1); } ep1 = d->v.kid->sibling; /* get expression */ if (ep1->type == NUM) return(ep1->v.num); /* return if number */ ep2 = ep1->sibling; /* check time */ if (eclock >= MAXCLOCK) eclock = 1; /* wrap clock counter */ if (ep2->v.tick < MAXCLOCK && (ep2->v.tick == 0) | (ep2->v.tick != eclock)) { ep2->v.tick = d->type == ':' ? MAXCLOCK : eclock; ep2 = ep2->sibling; ep2->v.num = evalue(ep1); /* needs new value */ } else ep2 = ep2->sibling; /* else reuse old value */ return(ep2->v.num); }
int t_func( /* compute texture for ray */ OBJREC *m, RAY *r ) { FVECT disp; double d; MFUNC *mf; int i; if (m->oargs.nsargs < 4) objerror(m, USER, "bad # arguments"); mf = getfunc(m, 3, 0x7, 1); setfunc(m, r); errno = 0; for (i = 0; i < 3; i++) { disp[i] = evalue(mf->ep[i]); if (errno == EDOM || errno == ERANGE) { objerror(m, WARNING, "compute error"); return(0); } } if (mf->fxp != &unitxf) multv3(disp, disp, mf->fxp->xfm); if (r->rox != NULL) { multv3(disp, disp, r->rox->f.xfm); d = 1.0 / (mf->fxp->sca * r->rox->f.sca); } else d = 1.0 / mf->fxp->sca; VSUM(r->pert, r->pert, disp, d); return(0); }
static void getacoords_as( /* set up coordinate system */ ASHIKDAT *np ) { MFUNC *mf; int i; mf = getfunc(np->mp, 3, 0x7, 1); setfunc(np->mp, np->rp); errno = 0; for (i = 0; i < 3; i++) np->u[i] = evalue(mf->ep[i]); if ((errno == EDOM) | (errno == ERANGE)) { objerror(np->mp, WARNING, "compute error"); np->specfl |= SPA_BADU; return; } if (mf->fxp != &unitxf) multv3(np->u, np->u, mf->fxp->xfm); fcross(np->v, np->pnorm, np->u); if (normalize(np->v) == 0.0) { objerror(np->mp, WARNING, "illegal orientation vector"); np->specfl |= SPA_BADU; return; } fcross(np->u, np->v, np->pnorm); }
static double edivi( EPNODE *ep ) { EPNODE *ep1 = ep->v.kid; double d; d = evalue(ep1->sibling); if (d == 0.0) { wputs("Division by zero\n"); errno = ERANGE; return(0.0); } return(evalue(ep1) / d); }
static void getacoords( /* set up coordinate system */ ANISODAT *np ) { MFUNC *mf; int i; mf = getfunc(np->mp, 3, 0x7, 1); setfunc(np->mp, np->rp); errno = 0; for (i = 0; i < 3; i++) np->u[i] = evalue(mf->ep[i]); if ((errno == EDOM) | (errno == ERANGE)) np->u[0] = np->u[1] = np->u[2] = 0.0; if (mf->fxp != &unitxf) multv3(np->u, np->u, mf->fxp->xfm); fcross(np->v, np->pnorm, np->u); if (normalize(np->v) == 0.0) { if (fabs(np->u_alpha - np->v_alpha) > 0.001) objerror(np->mp, WARNING, "illegal orientation vector"); getperpendicular(np->u, np->pnorm); /* punting */ fcross(np->v, np->pnorm, np->u); np->u_alpha = np->v_alpha = sqrt( 0.5 * (np->u_alpha*np->u_alpha + np->v_alpha*np->v_alpha) ); } else fcross(np->u, np->v, np->pnorm); }
static double euminus( EPNODE *ep ) { EPNODE *ep1 = ep->v.kid; return(-evalue(ep1)); }
void chanout( /* set output channels */ void (*cs)(int n, double v) ) { EPNODE *ep; for (ep = outchan; ep != NULL; ep = ep->sibling) (*cs)(ep->v.kid->v.chan, evalue(ep->v.kid->sibling)); }
double eval( /* evaluate an expression string */ char *expr ) { EPNODE *ep; double rval; ep = eparse(expr); rval = evalue(ep); epfree(ep); return(rval); }
static PyObject * pyns1_evalue(PyObject *self, PyObject *args) { PyObject *ret; char *plain; char *crypt; if(!PyArg_ParseTuple(args, "s", &plain)){ return NULL; } crypt = evalue(plain); ret = PyString_FromString(crypt); free(crypt); return ret; }
static void putrec(void) /* output a record */ { char fmt[32]; register int n; register struct field *f; int adlast, adnext; adlast = 0; for (f = outfmt; f != NULL; f = f->next) { adnext = blnkeq && f->next != NULL && !( (f->next->type&F_TYP) == T_LIT && f->next->f.sl[0] == ' ' ); switch (f->type & F_TYP) { case T_LIT: fputs(f->f.sl, stdout); adlast = f->f.sl[(f->type&F_WID)-1] != ' '; break; case T_STR: if (f->f.sv->val == NULL) { eputs(f->f.sv->name); eputs(": undefined string\n"); quit(1); } n = (int)(f->type & F_WID) - strlen(f->f.sv->val); if (adlast) fputs(f->f.sv->val, stdout); if (!(adlast && adnext)) while (n-- > 0) putchar(' '); if (!adlast) fputs(f->f.sv->val, stdout); adlast = 1; break; case T_NUM: n = f->type & F_WID; if (adlast && adnext) strcpy(fmt, "%g"); else if (adlast) sprintf(fmt, "%%-%dg", n); else sprintf(fmt, "%%%dg", n); printf(fmt, evalue(f->f.ne)); adlast = 1; break; } } }
extern int p_cfunc( /* compute color pattern */ OBJREC *m, RAY *r ) { COLOR cval; register MFUNC *mf; if (m->oargs.nsargs < 4) objerror(m, USER, "bad # arguments"); mf = getfunc(m, 3, 0x7, 0); setfunc(m, r); errno = 0; setcolor(cval, evalue(mf->ep[0]), evalue(mf->ep[1]), evalue(mf->ep[2])); if (errno == EDOM || errno == ERANGE) { objerror(m, WARNING, "compute error"); return(0); } multcolor(r->pcol, cval); return(0); }
int IAclass::calcMinMax(std::map<poseCase, typeCase>& mapLevel, int prof, bool isMax, int alpha, int beta) { int tmpNb = 0; poseCase poseActu(-1, -1); if(checkEndGame(mapLevel) == true || prof <= 0) { return evalue(mapLevel); } for(int i = 0; i < 7; ++i) { poseActu = coupPossible(mapLevel, i); if(poseActu == poseCase(-1, -1)) { continue; } mapLevel[poseActu] = isMax ? color : enemiColor; lastPose = poseActu; tmpNb = calcMinMax(mapLevel, prof - 1, !isMax, alpha, beta); mapLevel[poseActu] = VIDE; if(isMax) { if(tmpNb > alpha) { alpha = tmpNb; } if(alpha >= beta) { return alpha; } } else if(!isMax) { if(tmpNb < beta) { beta = tmpNb; } if(beta <= alpha) { return beta; } } } return (isMax ? alpha : beta); }
void kp_obj_show(ktap_state *ks, const ktap_value *v) { switch (ttype(v)) { case KTAP_TYPE_NIL: kp_puts(ks, "nil"); break; case KTAP_TYPE_NUMBER: kp_printf(ks, "%ld", nvalue(v)); break; case KTAP_TYPE_BOOLEAN: kp_puts(ks, (bvalue(v) == 1) ? "true" : "false"); break; case KTAP_TYPE_LIGHTUSERDATA: kp_printf(ks, "0x%lx", (unsigned long)pvalue(v)); break; case KTAP_TYPE_CFUNCTION: kp_printf(ks, "0x%lx", (unsigned long)fvalue(v)); break; case KTAP_TYPE_SHRSTR: case KTAP_TYPE_LNGSTR: kp_puts(ks, svalue(v)); break; case KTAP_TYPE_TABLE: kp_tab_dump(ks, hvalue(v)); break; #ifdef CONFIG_KTAP_FFI case KTAP_TYPE_CDATA: kp_cdata_dump(ks, cdvalue(v)); break; #endif case KTAP_TYPE_EVENT: kp_transport_event_write(ks, evalue(v)); break; case KTAP_TYPE_BTRACE: btrace_dump(ks, btvalue(v)); break; case KTAP_TYPE_PTABLE: kp_ptab_dump(ks, phvalue(v)); break; case KTAP_TYPE_STATDATA: kp_statdata_dump(ks, sdvalue(v)); break; default: kp_error(ks, "print unknown value type: %d\n", ttype(v)); break; } }
void kp_showobj(ktap_state *ks, const ktap_value *v) { switch (ttype(v)) { case KTAP_TNIL: kp_puts(ks, "nil"); break; case KTAP_TNUMBER: kp_printf(ks, "%ld", nvalue(v)); break; case KTAP_TBOOLEAN: kp_puts(ks, (bvalue(v) == 1) ? "true" : "false"); break; case KTAP_TLIGHTUSERDATA: kp_printf(ks, "0x%lx", (unsigned long)pvalue(v)); break; case KTAP_TLCF: kp_printf(ks, "0x%lx", (unsigned long)fvalue(v)); break; case KTAP_TSHRSTR: case KTAP_TLNGSTR: kp_puts(ks, svalue(v)); break; case KTAP_TUSERDATA: kp_printf(ks, "0x%lx", (unsigned long)uvalue(v)); break; case KTAP_TTABLE: kp_table_dump(ks, hvalue(v)); break; #ifdef __KERNEL__ case KTAP_TEVENT: kp_transport_event_write(ks, evalue(v)); break; case KTAP_TBTRACE: kp_btrace_dump(ks, btvalue(v)); break; case KTAP_TAGGRTABLE: kp_aggrtable_dump(ks, ahvalue(v)); break; case KTAP_TAGGRACCVAL: kp_aggraccval_dump(ks, aggraccvalue(v)); break; #endif default: kp_error(ks, "print unknown value type: %d\n", ttype(v)); break; } }
EPNODE * rconst( /* reduce a constant expression */ EPNODE *epar ) { EPNODE *ep; ep = newnode(); ep->type = NUM; errno = 0; ep->v.num = evalue(epar); if (errno == EDOM || errno == ERANGE) syntax("bad constant expression"); epfree(epar); return(ep); }
extern int p_bfunc( /* compute brightness pattern */ OBJREC *m, RAY *r ) { double bval; register MFUNC *mf; if (m->oargs.nsargs < 2) objerror(m, USER, "bad # arguments"); mf = getfunc(m, 1, 0x1, 0); setfunc(m, r); errno = 0; bval = evalue(mf->ep[0]); if (errno == EDOM || errno == ERANGE) { objerror(m, WARNING, "compute error"); return(0); } scalecolor(r->pcol, bval); return(0); }
QDCDDActorPrototype::QDCDDActorPrototype() { descriptor.setId("CDD"); descriptor.setDisplayName(QDCDDActor::tr("CDD")); descriptor.setDocumentation(QDCDDActor::tr("Finds annotations for DNA sequences in a remote database")); Descriptor evalue(EXPECT,QDCDDActor::tr("Expected value"), QDCDDActor::tr("This parameter specifies the statistical significance threshold of reporting matches against the database sequences.")); Descriptor qual(QUAL_ATTR, QDCDDActor::tr("Pattern"), QDCDDActor::tr("Include results containing specified value")); Descriptor minResLen(MIN_RES_LEN, QDCDDActor::tr("Min length"), QDCDDActor::tr("Minimum result length")); Descriptor maxResLen(MAX_RES_LEN, QDCDDActor::tr("Max length"), QDCDDActor::tr("Maximum result length")); attributes << new Attribute(evalue, BaseTypes::STRING_TYPE(), false, 10); attributes << new Attribute(minResLen, BaseTypes::NUM_TYPE(), false, 50); attributes << new Attribute(maxResLen, BaseTypes::NUM_TYPE(), false, 5000); attributes << new Attribute(qual, BaseTypes::STRING_TYPE(), true); QMap<QString, PropertyDelegate*> delegates; { QVariantMap m; m["1e-100"] = 1e-100; m["1e-10"] = 1e-10; m["1"] = 1; m["10"] = 10; m["100"] = 100; m["1000"] = 1000; delegates[EXPECT] = new ComboBoxDelegate(m); } { QVariantMap lenMap; lenMap["minimum"] = QVariant(0); lenMap["maximum"] = QVariant(INT_MAX); lenMap["suffix"] = L10N::suffixBp(); delegates[MIN_RES_LEN] = new SpinBoxDelegate(lenMap); delegates[MAX_RES_LEN] = new SpinBoxDelegate(lenMap); } editor = new DelegateEditor(delegates); }
int m_brdf( /* color a ray that hit a BRDTfunc material */ OBJREC *m, RAY *r ) { int hitfront = 1; BRDFDAT nd; RAY sr; double mirtest=0, mirdist=0; double transtest=0, transdist=0; int hasrefl, hastrans; int hastexture; COLOR ctmp; FVECT vtmp; double d; MFUNC *mf; int i; /* check arguments */ if ((m->oargs.nsargs < 10) | (m->oargs.nfargs < 9)) objerror(m, USER, "bad # arguments"); nd.mp = m; nd.pr = r; /* dummy values */ nd.rspec = nd.tspec = 1.0; nd.trans = 0.5; /* diffuse reflectance */ if (r->rod > 0.0) setcolor(nd.rdiff, m->oargs.farg[0], m->oargs.farg[1], m->oargs.farg[2]); else setcolor(nd.rdiff, m->oargs.farg[3], m->oargs.farg[4], m->oargs.farg[5]); /* diffuse transmittance */ setcolor(nd.tdiff, m->oargs.farg[6], m->oargs.farg[7], m->oargs.farg[8]); /* get modifiers */ raytexture(r, m->omod); hastexture = DOT(r->pert,r->pert) > FTINY*FTINY; if (hastexture) { /* perturb normal */ nd.pdot = raynormal(nd.pnorm, r); } else { VCOPY(nd.pnorm, r->ron); nd.pdot = r->rod; } if (r->rod < 0.0) { /* orient perturbed values */ nd.pdot = -nd.pdot; for (i = 0; i < 3; i++) { nd.pnorm[i] = -nd.pnorm[i]; r->pert[i] = -r->pert[i]; } hitfront = 0; } copycolor(nd.mcolor, r->pcol); /* get pattern color */ multcolor(nd.rdiff, nd.mcolor); /* modify diffuse values */ multcolor(nd.tdiff, nd.mcolor); hasrefl = bright(nd.rdiff) > FTINY; hastrans = bright(nd.tdiff) > FTINY; /* load cal file */ nd.dp = NULL; mf = getfunc(m, 9, 0x3f, 0); /* compute transmitted ray */ setbrdfunc(&nd); errno = 0; setcolor(ctmp, evalue(mf->ep[3]), evalue(mf->ep[4]), evalue(mf->ep[5])); if ((errno == EDOM) | (errno == ERANGE)) objerror(m, WARNING, "compute error"); else if (rayorigin(&sr, TRANS, r, ctmp) == 0) { if (!(r->crtype & SHADOW) && hastexture) { /* perturb direction */ VSUM(sr.rdir, r->rdir, r->pert, -.75); if (normalize(sr.rdir) == 0.0) { objerror(m, WARNING, "illegal perturbation"); VCOPY(sr.rdir, r->rdir); } } else { VCOPY(sr.rdir, r->rdir); } rayvalue(&sr); multcolor(sr.rcol, sr.rcoef); addcolor(r->rcol, sr.rcol); if (!hastexture) { transtest = 2.0*bright(sr.rcol); transdist = r->rot + sr.rt; } } if (r->crtype & SHADOW) /* the rest is shadow */ return(1); /* compute reflected ray */ setbrdfunc(&nd); errno = 0; setcolor(ctmp, evalue(mf->ep[0]), evalue(mf->ep[1]), evalue(mf->ep[2])); if ((errno == EDOM) | (errno == ERANGE)) objerror(m, WARNING, "compute error"); else if (rayorigin(&sr, REFLECTED, r, ctmp) == 0) { VSUM(sr.rdir, r->rdir, nd.pnorm, 2.*nd.pdot); checknorm(sr.rdir); rayvalue(&sr); multcolor(sr.rcol, sr.rcoef); addcolor(r->rcol, sr.rcol); if (!hastexture && r->ro != NULL && isflat(r->ro->otype)) { mirtest = 2.0*bright(sr.rcol); mirdist = r->rot + sr.rt; } } /* compute ambient */ if (hasrefl) { if (!hitfront) flipsurface(r); copycolor(ctmp, nd.rdiff); multambient(ctmp, r, nd.pnorm); addcolor(r->rcol, ctmp); /* add to returned color */ if (!hitfront) flipsurface(r); } if (hastrans) { /* from other side */ if (hitfront) flipsurface(r); vtmp[0] = -nd.pnorm[0]; vtmp[1] = -nd.pnorm[1]; vtmp[2] = -nd.pnorm[2]; copycolor(ctmp, nd.tdiff); multambient(ctmp, r, vtmp); addcolor(r->rcol, ctmp); if (hitfront) flipsurface(r); } if (hasrefl | hastrans || m->oargs.sarg[6][0] != '0') direct(r, dirbrdf, &nd); /* add direct component */ d = bright(r->rcol); /* set effective distance */ if (transtest > d) r->rt = transdist; else if (mirtest > d) r->rt = mirdist; return(1); }
static int redirect( /* compute n'th ray redirection */ OBJREC *m, RAY *r, int n ) { MFUNC *mf; EPNODE **va; FVECT nsdir; RAY nr; double coef; int j; /* set up function */ mf = getdfunc(m); setfunc(m, r); /* assign direction variable */ if (r->rsrc >= 0) { SRCREC *sp = source + source[r->rsrc].sa.sv.sn; if (sp->sflags & SDISTANT) VCOPY(nsdir, sp->sloc); else { for (j = 0; j < 3; j++) nsdir[j] = sp->sloc[j] - r->rop[j]; normalize(nsdir); } multv3(nsdir, nsdir, funcxf.xfm); varset("DxA", '=', nsdir[0]/funcxf.sca); varset("DyA", '=', nsdir[1]/funcxf.sca); varset("DzA", '=', nsdir[2]/funcxf.sca); } else { varset("DxA", '=', 0.0); varset("DyA", '=', 0.0); varset("DzA", '=', 0.0); } /* compute coefficient */ errno = 0; va = mf->ep + 4*n; coef = evalue(va[0]); if ((errno == EDOM) | (errno == ERANGE)) goto computerr; setcolor(nr.rcoef, coef, coef, coef); if (rayorigin(&nr, TRANS, r, nr.rcoef) < 0) return(0); va++; /* compute direction */ for (j = 0; j < 3; j++) { nr.rdir[j] = evalue(va[j]); if (errno == EDOM || errno == ERANGE) goto computerr; } if (mf->fxp != &unitxf) multv3(nr.rdir, nr.rdir, mf->fxp->xfm); if (r->rox != NULL) multv3(nr.rdir, nr.rdir, r->rox->f.xfm); if (normalize(nr.rdir) == 0.0) goto computerr; /* compute value */ if (r->rsrc >= 0) nr.rsrc = source[r->rsrc].sa.sv.sn; rayvalue(&nr); multcolor(nr.rcol, nr.rcoef); addcolor(r->rcol, nr.rcol); if (r->ro != NULL && isflat(r->ro->otype)) r->rt = r->rot + nr.rt; return(1); computerr: objerror(m, WARNING, "compute error"); return(-1); }
static int dir_proj( /* compute a director's projection */ MAT4 pm, OBJREC *o, SRCREC *s, int n ) { RAY tr; OBJREC *m; MFUNC *mf; EPNODE **va; FVECT cent, newdir, nv, h; double coef, olddot, newdot, od; int i, j; /* initialize test ray */ getmaxdisk(cent, o); if (s->sflags & SDISTANT) for (i = 0; i < 3; i++) { tr.rdir[i] = -s->sloc[i]; tr.rorg[i] = cent[i] - tr.rdir[i]; } else { for (i = 0; i < 3; i++) { tr.rdir[i] = cent[i] - s->sloc[i]; tr.rorg[i] = s->sloc[i]; } if (normalize(tr.rdir) == 0.0) return(0); /* at source! */ } od = getplaneq(nv, o); olddot = DOT(tr.rdir, nv); if (olddot <= FTINY && olddot >= -FTINY) return(0); /* old dir parallels plane */ tr.rmax = 0.0; rayorigin(&tr, PRIMARY, NULL, NULL); if (!(*ofun[o->otype].funp)(o, &tr)) return(0); /* no intersection! */ /* compute redirection */ m = vsmaterial(o); mf = getdfunc(m); setfunc(m, &tr); varset("DxA", '=', 0.0); varset("DyA", '=', 0.0); varset("DzA", '=', 0.0); errno = 0; va = mf->ep + 4*n; coef = evalue(va[0]); if (errno == EDOM || errno == ERANGE) goto computerr; if (coef <= FTINY) return(0); /* insignificant */ va++; for (i = 0; i < 3; i++) { newdir[i] = evalue(va[i]); if (errno == EDOM || errno == ERANGE) goto computerr; } if (mf->fxp != &unitxf) multv3(newdir, newdir, mf->fxp->xfm); /* normalization unnecessary */ newdot = DOT(newdir, nv); if (newdot <= FTINY && newdot >= -FTINY) return(0); /* new dir parallels plane */ /* everything OK -- compute shear */ for (i = 0; i < 3; i++) h[i] = newdir[i]/newdot - tr.rdir[i]/olddot; setident4(pm); for (j = 0; j < 3; j++) { for (i = 0; i < 3; i++) pm[i][j] += nv[i]*h[j]; pm[3][j] = -od*h[j]; } if ((newdot > 0.0) ^ (olddot > 0.0)) /* add mirroring */ for (j = 0; j < 3; j++) { for (i = 0; i < 3; i++) pm[i][j] -= 2.*nv[i]*nv[j]; pm[3][j] += 2.*od*nv[j]; } return(1); computerr: objerror(m, WARNING, "projection compute error"); return(0); }
void mainloop(Robot* robot) { /*** Initialisation ***/ rb = robot; oldE = 0.0f; /* Generate a random genom */ genom = 0; for(int i = 0; i < 3; ++i) { GENOM_SET (genom, rand_act(), i); } /* First movement */ move_reset(); switch(rand_act()) { case ACT_TURN_RIGHT: move_turn(PI/2.0f); break; case ACT_TURN_LEFT: move_turn(-PI/2.0f); break; } move_go(); /*** Loop ***/ for(;;) { if(rb->discover()) { char buffer[256]; int size; move_stop(); buffer[0] = 0xaa; rb->send(buffer, 1); size = rb->receive(buffer, 256); if(size != 1) { /* Taille invalide, on ignore */ rb->close(); move_go(); continue; } else { if(buffer[0] == (char)0xFF) { /* Connection à l'ordi central */ /* TODO */ rb->close(); move_go(); continue; } else { float E = evalue(); buffer[0] = ((genom & 0x3f) << 1); rb->memcpy(buffer + 1, &dist, 4); rb->memcpy(buffer + 5, &E, 4); rb->send(buffer, 9); float rdist; size = rb->receive(buffer, 256); rb->close(); if(size != 9 || (buffer[0] & 0x7e) != 0) { move_go(); continue; } rb->memcpy(&rdist, buffer + 1, 4); rb->memcpy(&E, buffer + 5, 4); if(evolve((buffer[0] & 0x3f) >> 1, E, rdist)) { move_reset(); } move_go(); continue; } } } float sc = rb->scan(); Action act; if(sc < DNEXT) { act = GENOM_GET(genom, NEXT); move_stop(); switch(act) { case ACT_TURN_RIGHT: move_turn(PI/2.0f); break; case ACT_TURN_LEFT: move_turn(-PI/2.0f); break; case ACT_STRAIGHT: move_turn(PI); break; } move_go(); } else if(sc < DNEAR) { act = GENOM_GET(genom, NEAR); move_stop(); switch(act) { case ACT_TURN_RIGHT: move_turn(PI/2.0f); break; case ACT_TURN_LEFT: move_turn(-PI/2.0f); break; } move_go(); } else if(sc < DFAR) { act = GENOM_GET(genom, FAR); move_stop(); switch(act) { case ACT_TURN_RIGHT: move_turn(PI/2.0f); break; case ACT_TURN_LEFT: move_turn(-PI/2.0f); break; } move_go(); } }
gmatch_t* alignkdmatches(void *space, Suffixarray *s, matchstem_t *M, CharSequence *query, char *curseq, Uint m, Uint t, Uint *enctab, unsigned char bestonly, Uint bedist, double lambda, double H, double K, double maxevalue, int acc, bitvector* D, Uint dim, Uint* nmatch, int* bscr) { Uint k,j,l,r,q,noofmatches=0, mat, mis, ins, del; Lint pos, margin, schr, echr, sstart, slen, i ; char *sseq; unsigned int idx; Alignment *al=NULL; bitvector *peq; PairSint result; #ifdef ALIGNDBG PairSint result2; CharSequence *checkseq; #endif double E; int scr; int maxedist = 0; int bestscr = 0; gmatch_t *matches=NULL; margin = bestscr = maxedist = m-ceil((acc*m)/100); peq = getpeq(NULL, curseq, m, s->seq->map, s->seq->mapsize, enctab); for(i=0; i < m; i++) { for(q=0; q < M[i].noofbranches; q++) { l = M[i].branches[q].l; r = M[i].branches[q].r; scr = M[i].branches[q].mat - (M[i].branches[q].mis+M[i].branches[q].ins+M[i].branches[q].del); E = evalue(lambda, K, spacemult(m, s->numofsuffixes, H, K), scr); if(l <= r && E <= maxevalue && (r-l) <= t) { for(j=l; j <= r; j++) { pos = s->suftab[j]; /*skip marginal matches*/ for(k=0; k < noofmatches; k++) if (abs((signed int)matches[k].p-(pos-(i+margin))) <= margin) break; if (k == noofmatches) { idx = getMultiCharSeqIndex(s->seq, &s->seq->sequences[pos]); schr = (idx > 0) ? s->seq->markpos[idx-1]+1 : 0; echr = s->seq->markpos[idx]; assert(echr >= pos); sstart = MAX(schr, pos-(i+margin)); slen = (echr > sstart+m+2*(margin+1)) ? m+2*(margin+1) : (echr-sstart)+1; sseq = &s->seq->sequences[sstart]; /* if(echr == pos) { fprintf(stderr, "\n\n sstart:%lld, slen:%lld, ssend:%lld, echr:%lld\n\n", sstart, slen, sstart+slen-1, echr); } */ myersbitmatrix(NULL, curseq, m, sseq, slen, s->seq->map, s->seq->mapsize, enctab, m-bestscr, peq, &result, D, slen); #ifdef ALIGNDBG result2 = myersbitvector(NULL, curseq, m, sseq, slen, s->seq->map, s->seq->mapsize, enctab, m-bestscr, peq); assert(result.a == result2.a && result.b == result2.b); #endif if (result.a != -1 && result.b <= maxedist && result.b <= bestscr && result.a < slen) { al = ALLOCMEMORY(space, NULL, Alignment, 1); initAlignment(al, curseq, m, 0, sseq, slen, 0); bitvectorbacktrack(al, D, slen, m, result.a); #ifdef ALIGNDBG assert(getEdist(al) == result.b); checkseq = (CharSequence*) s->seq->ref[idx].ref; assert(strncmp(& checkseq->sequence[pos-schr], &s->seq->sequences[pos], slen) == 0); #endif countEops(al, &mat, &mis, &del, &ins); /*skip identical matches*/ for(k=0; k < noofmatches; k++) { if (matches[k].p == sstart+al->voff) break; } if (k == noofmatches) { matches=realloc(matches, sizeof(gmatch_t)*(noofmatches+1)); matches[noofmatches].p = sstart+al->voff; matches[noofmatches].q = sstart+result.a-1; matches[noofmatches].edist = result.b; matches[noofmatches].i = i; matches[noofmatches].j = i+M[i].branches[q].mat+ M[i].branches[q].mis+M[i].branches[q].ins-1; matches[noofmatches].scr = scr; matches[noofmatches].evalue = E; matches[noofmatches].mat = mat; matches[noofmatches].mis = mis; matches[noofmatches].ins = ins; matches[noofmatches].del = del; matches[noofmatches].subject = idx; matches[noofmatches].checklen = matches[noofmatches].j; matches[noofmatches].al = al; noofmatches++; if(bestonly) { bestscr = MIN(maxedist, (result.b+bedist)); } } else { wrapAlignment(al); FREEMEMORY(space, al); } } } } } } } for(i=0; i < s->seq->mapsize; i++) { FREEMEMORY(space, peq[i]); } FREEMEMORY(space, peq); (*bscr) = bestscr; (*nmatch) = noofmatches; return matches; }