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