void printStackAndPc(int s[], int bp, int sp, int p[], int pc) {
printf("[ ");
int i;
for (i=0; i<=sp; i++)
if (IsInt(s[i]))
printf("%d ", Untag(s[i]));
else
printf("#%d ", s[i]);
printf("]");
printf("{%d:", pc); printInstruction(p, pc); printf("}\n");
}
Actor::~Actor()
{
StringSet::iterator it = _tags.begin();
while (it != _tags.end())
{
String tag = *it;
it++;
Untag(tag);
}
Actor::_nameList.erase(_name);
}
static void Gradient(This *t, ccount nfree, ccount *ifree,
cBounds *b, real *x, creal y, real *grad)
{
count i;
for( i = 0; i < nfree; ++i ) {
ccount dim = Untag(ifree[i]);
creal xd = x[dim];
creal delta = (b[dim].upper - xd < DELTA) ? -DELTA : DELTA;
x[dim] += delta;
grad[i] = (Sample(t, x) - y)/delta;
x[dim] = xd;
}
}
Experience::Experience(Vector2 pos)
{
_setUp = false;
_speed = 10.0f;
SetIsSensor(true); // make not collidable
pos.X += (MathUtil::RandomFloat(1.0) - 0.5);
pos.Y += (MathUtil::RandomFloat(1.0) - 0.5);
SetSprite("Resources/Images/exp1.png");
SetPosition(pos);
SetDrawShape(ADS_Square);
SetSize(MathUtil::RandomFloat(0.4) + 0.2);
//SetColor(0, 0.8, 0);
Untag("Enemy");
Tag("Experience");
InitPhysics();
theWorld.Add(this);
}
Actor::~Actor()
{
StringSet::iterator it = _tags.begin();
while (it != _tags.end())
{
String tag = *it;
it++;
Untag(tag);
}
Actor::_nameList.erase(_name);
StringSet subs = theSwitchboard.GetSubscriptionsFor(this);
it = subs.begin();
while (it != subs.end())
{
theSwitchboard.UnsubscribeFrom(this, *it);
++it;
}
}
static real Sample(This *t, creal *x0)
{
Vector(real, xtmp, 2*NDIM);
Vector(real, ftmp, 2*NCOMP);
real *xlast = xtmp, f;
real dist = 0;
count dim, comp;
number n = 1;
for( dim = 0; dim < t->ndim; ++dim ) {
creal x1 = *xlast++ = Min(Max(*x0++, 0.), 1.);
real dx;
if( (dx = x1 - t->border.lower) < 0 ||
(dx = x1 - t->border.upper) > 0 ) dist += Sq(dx);
}
if( dist > 0 ) {
dist = sqrt(dist)/EXTRAPOLATE_EPS;
for( dim = 0; dim < t->ndim; ++dim ) {
real x2 = xtmp[dim], dx, b;
if( (dx = x2 - (b = t->border.lower)) < 0 ||
(dx = x2 - (b = t->border.upper)) > 0 ) {
xtmp[dim] = b;
x2 = b - dx/dist;
}
*xlast++ = x2;
}
n = 2;
}
DoSample(t, n, xtmp, ftmp);
#define fin(x) Min(Max(x, -.5*INFTY), .5*INFTY)
comp = Untag(t->selectedcomp);
f = fin(ftmp[comp]);
if( n > 1 ) f += dist*(f - fin(ftmp[comp + t->ncomp]));
return Sign(t->selectedcomp)*f;
}
int execcode(int p[], int s[], int iargs[], int iargc, int /* boolean */ trace) {
int bp = -999; // Base pointer, for local variable access
int sp = -1; // Stack top pointer
int pc = 0; // Program counter: next instruction
for (;;) {
if (trace)
printStackAndPc(s, bp, sp, p, pc);
switch (p[pc++]) {
case CSTI:
s[sp+1] = Tag(p[pc++]); sp++; break;
case ADD:
s[sp-1] = Tag(Untag(s[sp-1]) + Untag(s[sp])); sp--; break;
case SUB:
s[sp-1] = Tag(Untag(s[sp-1]) - Untag(s[sp])); sp--; break;
case MUL:
s[sp-1] = Tag(Untag(s[sp-1]) * Untag(s[sp])); sp--; break;
case DIV:
s[sp-1] = Tag(Untag(s[sp-1]) / Untag(s[sp])); sp--; break;
case MOD:
s[sp-1] = Tag(Untag(s[sp-1]) % Untag(s[sp])); sp--; break;
case EQ:
s[sp-1] = Tag(s[sp-1] == s[sp] ? 1 : 0); sp--; break;
case LT:
s[sp-1] = Tag(s[sp-1] < s[sp] ? 1 : 0); sp--; break;
case NOT: {
int v = s[sp];
s[sp] = Tag((IsInt(v) ? Untag(v) == 0 : v == 0) ? 1 : 0);
} break;
case DUP:
s[sp+1] = s[sp]; sp++; break;
case SWAP:
{ int tmp = s[sp]; s[sp] = s[sp-1]; s[sp-1] = tmp; } break;
case LDI: // load indirect
s[sp] = s[Untag(s[sp])]; break;
case STI: // store indirect, keep value on top
s[Untag(s[sp-1])] = s[sp]; s[sp-1] = s[sp]; sp--; break;
case GETBP:
s[sp+1] = Tag(bp); sp++; break;
case GETSP:
s[sp+1] = Tag(sp); sp++; break;
case INCSP:
sp = sp+p[pc++]; break;
case GOTO:
pc = p[pc]; break;
case IFZERO: {
int v = s[sp--];
pc = (IsInt(v) ? Untag(v) == 0 : v == 0) ? p[pc] : pc+1;
} break;
case IFNZRO: {
int v = s[sp--];
pc = (IsInt(v) ? Untag(v) != 0 : v != 0) ? p[pc] : pc+1;
} break;
case CALL: {
int argc = p[pc++];
int i;
for (i=0; i<argc; i++) // Make room for return address
s[sp-i+2] = s[sp-i]; // and old base pointer
s[sp-argc+1] = Tag(pc+1); sp++;
s[sp-argc+1] = Tag(bp); sp++;
bp = sp+1-argc;
pc = p[pc];
} break;
case TCALL: {
int argc = p[pc++]; // Number of new arguments
int pop = p[pc++]; // Number of variables to discard
int i;
for (i=argc-1; i>=0; i--) // Discard variables
s[sp-i-pop] = s[sp-i];
sp = sp - pop; pc = p[pc];
} break;
case RET: {
int res = s[sp];
sp = sp-p[pc]; bp = Untag(s[--sp]); pc = Untag(s[--sp]);
s[sp] = res;
} break;
case PRINTI:
printf("%d ", IsInt(s[sp]) ? Untag(s[sp]) : s[sp]); break;
case PRINTC:
printf("%c", Untag(s[sp])); break;
case LDARGS: {
int i;
for (i=0; i<iargc; i++) // Push commandline arguments
s[++sp] = Tag(iargs[i]);
} break;
case STOP:
return 0;
case NIL:
s[sp+1] = 0; sp++; break;
case CONS: {
word* p = allocate(CONSTAG, 2, s, sp);
p[1] = (word)s[sp-1];
p[2] = (word)s[sp];
s[sp-1] = (int)p;
sp--;
} break;
case CAR: {
word* p = (word*)s[sp];
if (p == 0)
{ printf("Cannot take car of null\n"); return -1; }
s[sp] = (int)(p[1]);
} break;
case CDR: {
word* p = (word*)s[sp];
if (p == 0)
{ printf("Cannot take cdr of null\n"); return -1; }
s[sp] = (int)(p[2]);
} break;
case SETCAR: {
word v = (word)s[sp--];
word* p = (word*)s[sp];
p[1] = v;
} break;
case SETCDR: {
word v = (word)s[sp--];
word* p = (word*)s[sp];
p[2] = v;
} break;
default:
printf("Illegal instruction %d at address %d\n", p[pc-1], pc-1);
return -1;
}
}
}
static real FindMinimum(This *t, cBounds *b, real *xmin, real fmin)
{
Vector(real, hessian, NDIM*NDIM);
Vector(real, gfree, NDIM);
Vector(real, p, NDIM);
Vector(real, tmp, NDIM);
Vector(count, ifree, NDIM);
Vector(count, ifix, NDIM);
real ftmp, fini = fmin;
ccount maxeval = t->neval + 50*t->ndim;
count nfree, nfix;
count dim, local;
Clear(hessian, t->ndim*t->ndim);
for( dim = 0; dim < t->ndim; ++dim )
Hessian(dim, dim) = 1;
/* Step 1: - classify the variables as "fixed" (sufficiently close
to a border) and "free",
- if the integrand is flat in the direction of the gradient
w.r.t. the free dimensions, perform a local search. */
for( local = 0; local < 2; ++local ) {
bool resample = false;
nfree = nfix = 0;
for( dim = 0; dim < t->ndim; ++dim ) {
if( xmin[dim] < b[dim].lower + (1 + fabsx(b[dim].lower))*QEPS ) {
xmin[dim] = b[dim].lower;
ifix[nfix++] = dim;
resample = true;
}
else if( xmin[dim] > b[dim].upper - (1 + fabsx(b[dim].upper))*QEPS ) {
xmin[dim] = b[dim].upper;
ifix[nfix++] = Tag(dim);
resample = true;
}
else ifree[nfree++] = dim;
}
if( resample ) fini = fmin = Sample(t, xmin);
if( nfree == 0 ) goto releasebounds;
Gradient(t, nfree, ifree, b, xmin, fmin, gfree);
if( local || Length(nfree, gfree) > GTOL ) break;
ftmp = LocalSearch(t, nfree, ifree, b, xmin, fmin, tmp);
if( ftmp > fmin - (1 + fabsx(fmin))*RTEPS )
goto releasebounds;
fmin = ftmp;
XCopy(xmin, tmp);
}
while( t->neval <= maxeval ) {
/* Step 2a: perform a quasi-Newton iteration on the free
variables only. */
if( nfree > 0 ) {
real plen, pleneps;
real minstep;
count i, mini = 0, minfix = 0;
Point low;
LinearSolve(t, nfree, hessian, gfree, p);
plen = Length(nfree, p);
pleneps = plen + RTEPS;
minstep = INFTY;
for( i = 0; i < nfree; ++i ) {
count dim = Untag(ifree[i]);
if( fabsx(p[i]) > EPS ) {
real step;
count fix;
if( p[i] < 0 ) {
step = (b[dim].lower - xmin[dim])/p[i];
fix = dim;
}
else {
step = (b[dim].upper - xmin[dim])/p[i];
fix = Tag(dim);
}
if( step < minstep ) {
minstep = step;
mini = i;
minfix = fix;
}
}
}
if( minstep*pleneps <= DELTA ) {
fixbound:
ifix[nfix++] = minfix;
if( mini < --nfree ) {
creal diag = Hessian(mini, mini);
Clear(tmp, mini);
for( i = mini; i < nfree; ++i )
tmp[i] = Hessian(i + 1, mini);
for( i = mini; i < nfree; ++i ) {
Move(&Hessian(i, 0), &Hessian(i + 1, 0), i);
Hessian(i, i) = Hessian(i + 1, i + 1);
}
RenormalizeCholesky(t, nfree, hessian, tmp, diag);
Move(&ifree[mini], &ifree[mini + 1], nfree - mini);
Move(&gfree[mini], &gfree[mini + 1], nfree - mini);
}
continue;
}
low = LineSearch(t, nfree, ifree, p, xmin, fmin, tmp,
Min(minstep, 1.), Min(minstep, 100.), Dot(nfree, gfree, p),
RTEPS/pleneps, DELTA/pleneps, .2);
if( low.dx > 0 ) {
real fdiff;
fmin = low.f;
XCopy(xmin, tmp);
Gradient(t, nfree, ifree, b, xmin, fmin, tmp);
BFGS(t, nfree, hessian, tmp, gfree, p, low.dx);
XCopy(gfree, tmp);
if( fabsx(low.dx - minstep) < QEPS*minstep ) goto fixbound;
fdiff = fini - fmin;
fini = fmin;
if( fdiff > (1 + fabsx(fmin))*FTOL ||
low.dx*plen > (1 + Length(t->ndim, xmin))*FTOL ) continue;
}
}
/* Step 2b: check whether freeing any fixed variable will lead
to a reduction in f. */
releasebounds:
if( nfix > 0 ) {
real mingrad = INFTY;
count i, mini = 0;
bool repeat = false;
Gradient(t, nfix, ifix, b, xmin, fmin, tmp);
for( i = 0; i < nfix; ++i ) {
creal grad = Sign(ifix[i])*tmp[i];
if( grad < -RTEPS ) {
repeat = true;
if( grad < mingrad ) {
mingrad = grad;
mini = i;
}
}
}
if( repeat ) {
gfree[nfree] = tmp[mini];
ifree[nfree] = Untag(ifix[mini]);
Clear(&Hessian(nfree, 0), nfree);
Hessian(nfree, nfree) = 1;
++nfree;
--nfix;
Move(&ifix[mini], &ifix[mini + 1], nfix - mini);
continue;
}
}
break;
}
return fmin;
}
