void setauxvar(bodyptr btab, int nbody)
{
bodyptr bp;
vector jvec;
real jtot, etot, r0, r1, r;
if (streq(getparam("auxvar"), "mass"))
for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp))
Aux(bp) = mass_gsp(ggsp, absv(Pos(bp)));
else if (streq(getparam("auxvar"), "rperi"))
for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) {
CROSSVP(jvec, Pos(bp), Vel(bp));
jtot = absv(jvec);
etot = 0.5 * dotvp(Vel(bp), Vel(bp)) + Phi(bp);
r0 = 0.0;
r1 = absv(Pos(bp));
r = 0.5 * (r0 + r1);
while ((r1 - r0) > TOL * r) {
if (rsqrt(2 * (etot - phi_gsp(ggsp, r))) > jtot/r)
r1 = r;
else
r0 = r;
r = 0.5 * (r0 + r1);
}
Aux(bp) = r;
}
else
error("%s: unknown auxvar option %s\n",
getargv0(), getparam("auxvar"));
}
programData pd(programAux aux = Aux(), Node code=token("_"), int outs=0) {
programData o;
o.aux = aux;
o.code = code;
o.outs = outs;
return o;
}
// Compiled fragtree -> compiled fragtree without labels
Node dereference(Node program) {
int sz = treeSize(program) * 4;
int labelLength = 1;
while (sz >= 256) { labelLength += 1; sz /= 256; }
programAux aux = buildDict(program, Aux(), labelLength);
return substDict(program, aux, labelLength);
}
void polymodel(void)
{
gsl_interp_accel *pmsplacc = gsl_interp_accel_alloc();
bodyptr p;
real rad, phi, vel, psi, vr, vp, a, E, J;
vector rhat, vtmp, vper;
for (p = btab; p < NthBody(btab, nbody); p = NextBody(p)) {
rad = rad_m(xrandom(0.0, mtot));
phi = gsl_spline_eval(pmspline, (double) rad, pmsplacc);
vel = pick_v(phi);
psi = pick_psi();
vr = vel * rcos(psi);
vp = vel * rsin(psi);
Mass(p) = mtot / nbody;
pickshell(rhat, NDIM, 1.0);
MULVS(Pos(p), rhat, rad);
pickshell(vtmp, NDIM, 1.0);
a = dotvp(vtmp, rhat);
MULVS(vper, rhat, - a);
ADDV(vper, vper, vtmp);
a = absv(vper);
MULVS(vper, vper, vp / a);
MULVS(Vel(p), rhat, vr);
ADDV(Vel(p), Vel(p), vper);
Phi(p) = phi;
E = phi + 0.5 * rsqr(vel);
J = rad * ABS(vp);
Aux(p) = Kprime * rpow(phi1 - E, npol - 1.5) * rpow(J, 2 * mpol);
}
gsl_interp_accel_free(pmsplacc);
}
// Compiled fragtree -> compiled fragtree without labels
std::vector<Node> dereference(Node program) {
int sz = treeSize(program) * 4;
int labelLength = 1;
while (sz >= 256) { labelLength += 1; sz /= 256; }
programAux aux = Aux();
buildDict(program, aux, labelLength);
std::vector<Node> o;
substDict(program, aux, labelLength, o);
return o;
}
void grafo::KRUSKAL(void)
{
// pesquisa entre as arestas não ligadas a com menor peso e que não gere loop
vector<bool> AuX(size());
vector<vector<bool> > AUX(size());
num N=size();
for( num k=0; k<size()-1; k++) {
AUX[k]=vector<bool>(size());
for( num t=k+1; t<size(); t++)
if(connected(k,t)) {
AUX[k][t]=AUX[t][k]=AuX[k]=AuX[t]=true;
N-=2;
}
}
while(N>0)
// for( num s=0; s<100*199; s++)
{
vector<bool> Aux(size());
weight aux=INF;
vertex v=0, w=0;
for( num i=0; i<size()-1; i++)
for( num j=i+1; j<size(); j++)
if( !AUX[i][j] & getw(i,j) < aux) {
aux=getw(i,j);
v=i; w=j;
}
// cout << v << "->" << w << " " << aux << endl;
if(aux==INF) return;
AUX[v][w]=AUX[w][v]=true;
insert(v, w);
// cout << endl << "check loop" << endl;
if(in_loop(v, v, v, Aux) ) {
// if( !AuX[v] | !AuX[w])
// insert(v,w);
// cout << "loop" << endl;
remove(v,w);
}
// else
// continue;
// cout << endl << "end ckeck loop" << endl;
if( !AuX[v]) N--;
if( !AuX[w]) N--;
AuX[v]=AuX[w]=true;
// for( num s=0; s<size(); s++)
// cout << AuX[s];
// cout << endl;
// cout << k << endl;
}
}
int main(int argc, string argv[])
{
stream fstr, istr, ostr;
gsprof *gsp;
bodyptr btab = NULL, p;
int nbody;
real tnow, r;
string intags[MaxBodyFields];
initparam(argv, defv);
layout_body(bodyfields, Precision, NDIM);
fstr = stropen(getparam("gsp"), "r");
get_history(fstr);
gsp = get_gsprof(fstr);
istr = stropen(getparam("in"), "r");
get_history(istr);
if (! get_snap(istr, &btab, &nbody, &tnow, intags, TRUE))
error("%s: snapshot input failed\n", getargv0());
if (! set_member(intags, PosTag))
error("%s: position data missing\n", getargv0());
if (streq(getparam("option"), "rho"))
for (p = btab; p < NthBody(btab, nbody); p = NextBody(p))
Aux(p) = rho_gsp(gsp, absv(Pos(p)));
else if (streq(getparam("option"), "drho"))
for (p = btab; p < NthBody(btab, nbody); p = NextBody(p))
Aux(p) = drho_gsp(gsp, absv(Pos(p)));
else if (streq(getparam("option"), "mass"))
for (p = btab; p < NthBody(btab, nbody); p = NextBody(p))
Aux(p) = mass_gsp(gsp, absv(Pos(p)));
else if (streq(getparam("option"), "phi"))
for (p = btab; p < NthBody(btab, nbody); p = NextBody(p))
Aux(p) = phi_gsp(gsp, absv(Pos(p)));
else
error("%s: unknown option %s\n", getargv0(), getparam("option"));
if (! strnull(getparam("out"))) {
ostr = stropen(getparam("out"), "w");
put_history(ostr);
put_snap(ostr, &btab, &nbody, &tnow, set_union(bodyfields, intags));
strclose(ostr);
}
return (0);
}
void Triangle::swap(Triangle &T , QVector<QPoint> &voisins , QVector<QPoint> &swapsFutures)
{
if (this->estAdjacentA(T)) {
//permutations circulaires pour rendre les points non communs au début des structures
//qDebug() << "triangle.swap: triangle initiaux " ;
//this->afficher();
//T.afficher();
this->permut(this->trouverAdjacent(T.id));
T.permut(T.trouverAdjacent(this->id));
//qDebug() << "triangle.swap: permutation ";
//this->afficher() ;
//T.afficher() ;
Triangle Aux(0) ;
this->copierVers(Aux);
this->sommets[0] = Aux.sommets[2] ;
this->sommets[1] = Aux.sommets[0] ;
this->sommets[2] = T.sommets[0] ;
this->adjacents[2] = this->adjacents[1] ;
this->adjacents[1] = T.adjacents[2] ;
T.sommets[0] = Aux.sommets[1] ;
T.sommets[1] = this->sommets[2] ;
T.sommets[2] = this->sommets[1] ;
T.adjacents[2] = T.adjacents[1] ;
T.adjacents[1] = Aux.adjacents[2] ;
//qDebug() << "triangle.swap: triangle swapes" ;
//this->afficher() ;
//T.afficher();
voisins.clear();
//T4 est maintenant voisin de T2 , eliminer T1 de la liste des voisins
voisins.push_back(QPoint(T.id , T.adjacents[1]));
//T6 est maintenant voisin de T1 , eliminer T2 de la liste des voisins
voisins.push_back(QPoint(this->id, this->adjacents[1]));
//*
//liste de swaps prochains
if (this->adjacents[1]>=0) swapsFutures.push_back( QPoint(this->id , this->adjacents[1]));
if (this->adjacents[2]>=0) swapsFutures.push_back( QPoint(this->id , this->adjacents[2]));
if (T.adjacents[1] >= 0) swapsFutures.push_back( QPoint(T.id , T.adjacents[1]));
if (T.adjacents[2] >= 0) swapsFutures.push_back( QPoint(T.id , T.adjacents[2]));
//*/
//qDebug() << "from triangle.swap nouveaux voisins" << voisins;
}
}
/*Cuad. Form C = b^T A b*/
double CuadForm(Matrix &A, Matrix &b) {
//Make the auxiliar (vector) matrix
Matrix Aux(A.nRow());
Matrix res(1);
gsl_blas_dgemm( CblasNoTrans, CblasNoTrans, 1.0, A.Ma(), b.Ma(), 0.0, Aux.Ma());
gsl_blas_dgemm( CblasTrans, CblasNoTrans, 1.0, b.Ma(), Aux.Ma(), 0.0, res.Ma());
return res(0);
}
int Matrix::multiplication(Matrix* matA, Matrix* matB, Matrix* matC)
{
//Comprobaciones previas
//To do
//Multiplicacion
Matrix Aux(matA->numFilas,matB->numColumnas);
Aux.multiplication(matA,matB);
multiplication(&Aux,matC);
Aux.deletion();
//End
return 1;
}
void gspmodel(void)
{
real beta_a, mcut, vcut, vfac;
static real *sig2 = NULL;
real r, vmax2, sigr, sig, x, y, vr, v1, v2;
bodyptr bp;
vector rhat, vec1, vec2, vtmp;
beta_a = getdparam("beta_a");
assert(beta_a <= 1.0);
nbody = getiparam("nbody");
assert(nbody > 0);
mcut = getdparam("mcut");
assert(0.0 < mcut && mcut <= 1.0);
vcut = getdparam("vcut");
assert(vcut > 0.0);
if (sig2 == NULL)
sig2 = calc_sig2_gsp(gsp, ggsp, beta_a);
if (btab == NULL)
btab = (bodyptr) allocate(nbody * SizeofBody);
vfac = rsqrt(1 - beta_a);
for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) {
Mass(bp) = gsp->mtot / nbody;
r = r_mass_gsp(gsp, xrandom(0.0, mcut * gsp->mtot));
vmax2 = -2 * rsqr(vcut) * phi_gsp(ggsp, r);
if (vfac > 1.0)
vmax2 = vmax2 / rsqr(vfac);
sigr = rsqrt(sig2_gsp(gsp, ggsp, beta_a, sig2, r));
sig = fixsigma(sigr, rsqrt(vmax2));
do {
vr = grandom(0.0, sig);
v1 = grandom(0.0, sig);
v2 = grandom(0.0, sig);
} while (vr*vr + v1*v1 + v2*v2 > vmax2);
picktriad(rhat, vec1, vec2);
MULVS(Pos(bp), rhat, r);
MULVS(Vel(bp), rhat, vr);
MULVS(vtmp, vec1, v1 * vfac);
ADDV(Vel(bp), Vel(bp), vtmp);
MULVS(vtmp, vec2, v2 * vfac);
ADDV(Vel(bp), Vel(bp), vtmp);
Phi(bp) = phi_gsp(ggsp, r);
Aux(bp) = Phi(bp) + 0.5 * dotvp(Vel(bp), Vel(bp));
}
if (getbparam("besort"))
qsort(btab, nbody, SizeofBody, berank);
if (getbparam("zerocm"))
snapcenter(btab, nbody, MassField.offset);
if (! strnull(getparam("auxvar")))
setauxvar(btab, nbody);
}
// Builds a dictionary mapping labels to variable names
programAux buildDict(Node program, programAux aux, int labelLength) {
Metadata m = program.metadata;
// Token
if (program.type == TOKEN) {
if (isNumberLike(program)) {
aux.step += 1 + toByteArr(program.val, m).size();
}
else if (program.val[0] == '~') {
aux.vars[program.val.substr(1)] = unsignedToDecimal(aux.step);
}
else if (program.val[0] == '$') {
aux.step += labelLength + 1;
}
else aux.step += 1;
}
// A sub-program (ie. LLL)
else if (program.val == "____CODE") {
programAux auks = Aux();
for (unsigned i = 0; i < program.args.size(); i++) {
auks = buildDict(program.args[i], auks, labelLength);
}
for (std::map<std::string,std::string>::iterator it=auks.vars.begin();
it != auks.vars.end();
it++) {
aux.vars[(*it).first] = (*it).second;
}
aux.step += auks.step;
}
// Normal sub-block
else {
for (unsigned i = 0; i < program.args.size(); i++) {
aux = buildDict(program.args[i], aux, labelLength);
}
}
return aux;
}
int berank(const void *a, const void *b)
{
return (Aux((bodyptr) a) < Aux((bodyptr) b) ? -1 :
Aux((bodyptr) a) > Aux((bodyptr) b) ? 1 : 0);
}
void print_data(bodyptr btab, int nbody, real tnow, string *fields,
string ifmt, string rfmt)
{
bodyptr bp;
for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) {
if (set_member(fields, TimeTag))
printf(rfmt, tnow);
if (set_member(fields, MassTag))
printf(rfmt, Mass(bp));
if (set_member(fields, PosTag)) {
printf(rfmt, Pos(bp)[0]);
printf(rfmt, Pos(bp)[1]);
printf(rfmt, Pos(bp)[2]);
}
if (set_member(fields, VelTag)) {
printf(rfmt, Vel(bp)[0]);
printf(rfmt, Vel(bp)[1]);
printf(rfmt, Vel(bp)[2]);
}
if (set_member(fields, AccTag)) {
printf(rfmt, Acc(bp)[0]);
printf(rfmt, Acc(bp)[1]);
printf(rfmt, Acc(bp)[2]);
}
if (set_member(fields, PhiTag))
printf(rfmt, Phi(bp));
if (set_member(fields, SmoothTag))
printf(rfmt, Smooth(bp));
if (set_member(fields, RhoTag))
printf(rfmt, Rho(bp));
if (set_member(fields, EntFuncTag))
printf(rfmt, EntFunc(bp));
if (set_member(fields, UinternTag))
printf(rfmt, Uintern(bp));
if (set_member(fields, UdotIntTag))
printf(rfmt, UdotInt(bp));
if (set_member(fields, UdotRadTag))
printf(rfmt, UdotRad(bp));
if (set_member(fields, UdotVisTag))
printf(rfmt, UdotVis(bp));
if (set_member(fields, TauTag))
printf(rfmt, Tau(bp));
if (set_member(fields, BirthTag))
printf(rfmt, Birth(bp));
if (set_member(fields, DeathTag))
printf(rfmt, Death(bp));
if (set_member(fields, TypeTag))
printf(ifmt, (int) Type(bp));
if (set_member(fields, KeyTag))
printf(ifmt, Key(bp));
if (set_member(fields, AuxTag))
printf(rfmt, Aux(bp));
if (set_member(fields, AuxVecTag)) {
printf(rfmt, AuxVec(bp)[0]);
printf(rfmt, AuxVec(bp)[1]);
printf(rfmt, AuxVec(bp)[2]);
}
printf("\n");
}
}
plotsnap()
{
real t, *mp, *psp, *pp, *ap, *acp;
int vismax, visnow, i, vis, icol;
real psz, col, x, y, z;
Body b;
bool Qall = FALSE;
t = (timeptr != NULL ? *timeptr : 0.0); /* get current time value */
CLRV(Acc(&b)); /* zero unsupported fields */
Key(&b) = 0;
visnow = vismax = 0;
do { /* loop painting layers */
visnow++; /* make next layer visib. */
mp = massptr; /* (re)set data pointers */
psp = phaseptr;
pp = phiptr;
ap = auxptr;
acp = accptr;
npnt = 0;
for (i = 0; i < nbody; i++) { /* loop over all bodies */
Mass(&b) = (mp != NULL ? *mp++ : 0.0);
/* set mass if supplied */
SETV(Pos(&b), psp); /* always set position */
psp += NDIM; /* and advance p.s. ptr */
SETV(Vel(&b), psp); /* always set velocity */
psp += NDIM; /* and advance ptr */
Phi(&b) = (pp != NULL ? *pp++ : 0.0);
Aux(&b) = (ap != NULL ? *ap++ : 0.0);
if (acp) {
SETV(Acc(&b),acp); /* set accel's */
acp += NDIM; /* and advance ptr */
}
/* set phi,aux if given */
vis = (*vfunc)(&b, t, i); /* evaluate visibility */
vismax = MAX(vismax, vis); /* remember how hi to go*/
if (vis == visnow) { /* if body is visible */
x = (*xfunc)(&b, t, i); /* evaluate x,y,z coords*/
y = (*yfunc)(&b, t, i);
z = (*zfunc)(&b, t, i);
psz = (*pfunc)(&b, t, i);
#define MAXCOLOR 16
#ifdef COLOR
col = (*cfunc)(&b, t, i);
col = (col - crange[0])/(crange[1] - crange[0]);
icol = 1 + (MAXCOLOR - 2) * MAX(0.0, MIN(1.0, col));
s2sci(icol);
#endif
xpnt[npnt] = x;
ypnt[npnt] = y;
zpnt[npnt] = z;
if (!Qall) {
s2pt1(xpnt[npnt],ypnt[npnt],zpnt[npnt], visnow);
}
npnt++;
}
} /* i<nbody */
if (Qall)
s2pt(npnt, xpnt, ypnt, zpnt, visnow);
} while (visnow < vismax); /* until final layer done */
}
// Turns LLL tree into tree of code fragments
programData opcodeify(Node node,
programAux aux=Aux(),
int height=0,
std::map<std::string, int> dupvars=
std::map<std::string, int>()) {
std::string symb = "_"+mkUniqueToken();
Metadata m = node.metadata;
// Numbers
if (node.type == TOKEN) {
return pd(aux, nodeToNumeric(node), 1);
}
else if (node.val == "ref" || node.val == "get" || node.val == "set") {
std::string varname = node.args[0].val;
if (!aux.vars.count(varname)) {
aux.vars[varname] = unsignedToDecimal(aux.vars.size() * 32);
}
std::cout << aux.vars[varname] << " " << varname << " " << node.val << "\n";
if (varname == "'msg.data") aux.calldataUsed = true;
// Set variable
if (node.val == "set") {
programData sub = opcodeify(node.args[1], aux, height, dupvars);
if (!sub.outs)
err("Value to set variable must have nonzero arity!", m);
if (dupvars.count(node.args[0].val)) {
int h = height - dupvars[node.args[0].val];
if (h > 16) err("Too deep for stack variable (max 16)", m);
Node nodelist[] = {
sub.code,
token("SWAP"+unsignedToDecimal(h), m),
token("POP", m)
};
return pd(sub.aux, multiToken(nodelist, 3, m), 0);
}
Node nodelist[] = {
sub.code,
token(sub.aux.vars[varname], m),
token("MSTORE", m),
};
return pd(sub.aux, multiToken(nodelist, 3, m), 0);
}
// Get variable
else if (node.val == "get") {
if (dupvars.count(node.args[0].val)) {
int h = height - dupvars[node.args[0].val];
if (h > 16) err("Too deep for stack variable (max 16)", m);
return pd(aux, token("DUP"+unsignedToDecimal(h)), 1);
}
Node nodelist[] =
{ token(aux.vars[varname], m), token("MLOAD", m) };
std::cout << "<--- " << aux.vars[varname] << " " << varname << "\n";
return pd(aux, multiToken(nodelist, 2, m), 1);
}
// Refer variable
else {
if (dupvars.count(node.args[0].val))
err("Cannot ref stack variable!", m);
return pd(aux, token(aux.vars[varname], m), 1);
}
}
// Code blocks
if (node.val == "lll" && node.args.size() == 2) {
if (node.args[1].val != "0") aux.allocUsed = true;
std::vector<Node> o;
o.push_back(finalize(opcodeify(node.args[0])));
programData sub = opcodeify(node.args[1], aux, height, dupvars);
Node code = astnode("____CODE", o, m);
Node nodelist[] = {
token("$begincode"+symb+".endcode"+symb, m), token("DUP1", m),
token("$begincode"+symb, m), sub.code, token("CODECOPY", m),
token("$endcode"+symb, m), token("JUMP", m),
token("~begincode"+symb, m), code, token("~endcode"+symb, m)
};
return pd(sub.aux, multiToken(nodelist, 10, m), 1);
}
// Stack variables
if (node.val == "with") {
std::map<std::string, int> dupvars2 = dupvars;
dupvars2[node.args[0].val] = height;
programData initial = opcodeify(node.args[1], aux, height, dupvars);
if (!initial.outs)
err("Initial variable value must have nonzero arity!", m);
programData sub = opcodeify(node.args[2], initial.aux, height + 1, dupvars2);
Node nodelist[] = {
initial.code,
sub.code
};
programData o = pd(sub.aux, multiToken(nodelist, 2, m), sub.outs);
if (sub.outs)
o.code.args.push_back(token("SWAP1", m));
o.code.args.push_back(token("POP", m));
return o;
}
// Seq of multiple statements
if (node.val == "seq") {
std::vector<Node> children;
int lastOut = 0;
for (unsigned i = 0; i < node.args.size(); i++) {
programData sub = opcodeify(node.args[i], aux, height, dupvars);
aux = sub.aux;
if (sub.outs == 1) {
if (i < node.args.size() - 1) sub.code = popwrap(sub.code);
else lastOut = 1;
}
children.push_back(sub.code);
}
return pd(aux, astnode("_", children, m), lastOut);
}
// 2-part conditional (if gets rewritten to unless in rewrites)
else if (node.val == "unless" && node.args.size() == 2) {
programData cond = opcodeify(node.args[0], aux, height, dupvars);
programData action = opcodeify(node.args[1], cond.aux, height, dupvars);
aux = action.aux;
if (!cond.outs) err("Condition of if/unless statement has arity 0", m);
if (action.outs) action.code = popwrap(action.code);
Node nodelist[] = {
cond.code,
token("$endif"+symb, m), token("JUMPI", m),
action.code,
token("~endif"+symb, m)
};
return pd(aux, multiToken(nodelist, 5, m), 0);
}
// 3-part conditional
else if (node.val == "if" && node.args.size() == 3) {
programData ifd = opcodeify(node.args[0], aux, height, dupvars);
programData thend = opcodeify(node.args[1], ifd.aux, height, dupvars);
programData elsed = opcodeify(node.args[2], thend.aux, height, dupvars);
aux = elsed.aux;
if (!ifd.outs)
err("Condition of if/unless statement has arity 0", m);
// Handle cases where one conditional outputs something
// and the other does not
int outs = (thend.outs && elsed.outs) ? 1 : 0;
if (thend.outs > outs) thend.code = popwrap(thend.code);
if (elsed.outs > outs) elsed.code = popwrap(elsed.code);
Node nodelist[] = {
ifd.code,
token("NOT", m), token("$else"+symb, m), token("JUMPI", m),
thend.code,
token("$endif"+symb, m), token("JUMP", m), token("~else"+symb, m),
elsed.code,
token("~endif"+symb, m)
};
return pd(aux, multiToken(nodelist, 10, m), outs);
}
// While (rewritten to this in rewrites)
else if (node.val == "until") {
programData cond = opcodeify(node.args[0], aux, height, dupvars);
programData action = opcodeify(node.args[1], cond.aux, height, dupvars);
aux = action.aux;
if (!cond.outs)
err("Condition of while/until loop has arity 0", m);
if (action.outs) action.code = popwrap(action.code);
Node nodelist[] = {
token("~beg"+symb, m),
cond.code,
token("$end"+symb, m), token("JUMPI", m),
action.code,
token("$beg"+symb, m), token("JUMP", m), token("~end"+symb, m)
};
return pd(aux, multiToken(nodelist, 8, m));
}
// Memory allocations
else if (node.val == "alloc") {
programData bytez = opcodeify(node.args[0], aux, height, dupvars);
aux = bytez.aux;
if (!bytez.outs)
err("Alloc input has arity 0", m);
aux.allocUsed = true;
Node nodelist[] = {
bytez.code,
token("MSIZE", m), token("SWAP1", m), token("MSIZE", m),
token("ADD", m),
token("0", m), token("SWAP1", m), token("MSTORE", m)
};
return pd(aux, multiToken(nodelist, 8, m), 1);
}
// Array literals
else if (node.val == "array_lit") {
aux.allocUsed = true;
std::vector<Node> nodes;
if (!node.args.size()) {
nodes.push_back(token("MSIZE", m));
return pd(aux, astnode("_", nodes, m));
}
nodes.push_back(token("MSIZE", m));
nodes.push_back(token("0", m));
nodes.push_back(token("MSIZE", m));
nodes.push_back(token(unsignedToDecimal(node.args.size() * 32 - 1), m));
nodes.push_back(token("ADD", m));
nodes.push_back(token("MSTORE8", m));
for (unsigned i = 0; i < node.args.size(); i++) {
Metadata m2 = node.args[i].metadata;
nodes.push_back(token("DUP1", m2));
programData sub = opcodeify(node.args[i], aux, height + 2, dupvars);
if (!sub.outs)
err("Array_lit item " + unsignedToDecimal(i) + " has zero arity", m2);
aux = sub.aux;
nodes.push_back(sub.code);
nodes.push_back(token("SWAP1", m2));
if (i > 0) {
nodes.push_back(token(unsignedToDecimal(i * 32), m2));
nodes.push_back(token("ADD", m2));
}
nodes.push_back(token("MSTORE", m2));
}
return pd(aux, astnode("_", nodes, m), 1);
}
// All other functions/operators
else {
std::vector<Node> subs2;
int depth = opinputs(upperCase(node.val));
if (node.val != "debug") {
if (depth == -1)
err("Not a function or opcode: "+node.val, m);
if ((int)node.args.size() != depth)
err("Invalid arity for "+node.val, m);
}
for (int i = node.args.size() - 1; i >= 0; i--) {
programData sub = opcodeify(node.args[i],
aux,
height - i - 1 + node.args.size(),
dupvars);
aux = sub.aux;
if (!sub.outs)
err("Input "+unsignedToDecimal(i)+" has arity 0", sub.code.metadata);
subs2.push_back(sub.code);
}
if (node.val == "debug") {
subs2.push_back(token("DUP"+unsignedToDecimal(node.args.size()), m));
for (int i = 0; i <= (int)node.args.size(); i++)
subs2.push_back(token("POP", m));
}
else subs2.push_back(token(upperCase(node.val), m));
int outdepth = node.val == "debug" ? 0 : opoutputs(upperCase(node.val));
return pd(aux, astnode("_", subs2, m), outdepth);
}
}
void nemo_main()
{
stream instr, outstr;
real mscale, pscale, xscale, tsnap, escale, dscale;
vector rscale, vscale, ascale;
string times;
int i, nbody, bits, nrscale, nvscale, nascale, kscale;
Body *btab = NULL, *bp;
bool Qmass, Qphase, Qacc, Qpot, Qkey, Qaux, Qeps, Qdens;
nrscale = nemoinpr(getparam("rscale"),rscale,NDIM); /* RSCALE */
if (nrscale==1)
for (i=1; i<NDIM; i++)
rscale[i] = rscale[0];
else if (nrscale!=NDIM)
error("keyword rscale needs either 1 or %d numbers", NDIM);
nvscale = nemoinpr(getparam("vscale"),vscale,NDIM); /* VSCALE */
if (nvscale==1)
for (i=1; i<NDIM; i++)
vscale[i] = vscale[0];
else if (nvscale!=NDIM)
error("keyword vscale needs either 1 or %d numbers", NDIM);
nascale = nemoinpr(getparam("ascale"),ascale,NDIM); /* ASCALE */
if (nascale==1)
for (i=1; i<NDIM; i++)
ascale[i] = ascale[0];
else if (nascale!=NDIM)
error("keyword ascale needs either 1 or %d numbers", NDIM);
mscale = getdparam("mscale");
pscale = getdparam("pscale");
xscale = getdparam("xscale");
dscale = getdparam("dscale");
escale = getdparam("escale");
kscale = getiparam("kscale");
times = getparam("times");
instr = stropen(getparam("in"), "r"); /* open files */
outstr = stropen(getparam("out"), "w");
get_history(instr);
put_history(outstr);
for (;;) {
get_history(instr); /* skip over stuff we can forget */
if (!get_tag_ok(instr, SnapShotTag))
break; /* done with work in loop */
get_snap(instr, &btab, &nbody, &tsnap, &bits);
if ((bits & MassBit) == 0 && (bits & PhaseSpaceBit) == 0) {
continue; /* just skip it's probably a diagnostics */
}
if ((bits & TimeBit) == 0)
tsnap = 0.0;
else if (!streq(times,"all") && !within(tsnap, times, TIMEFUZZ))
continue;
dprintf (1,"Scaling snapshot at time= %f bits=0x%x\n",tsnap,bits);
Qmass = MassBit & bits && !uscalar(mscale);
Qphase = PhaseSpaceBit & bits &&(!uvector(rscale) || !uvector(vscale));
Qacc = AccelerationBit & bits&& !uvector(ascale);
Qpot = PotentialBit & bits && !uscalar(pscale);
Qaux = AuxBit & bits && !uscalar(xscale);
Qkey = KeyBit & bits && (kscale!=1);
Qdens = DensBit & bits && !uscalar(dscale);
Qeps = EpsBit & bits && !uscalar(escale);
dprintf(1,"Scaling: ");
if (Qmass) dprintf(1," mass");
if (Qphase) dprintf(1," phase");
if (Qacc) dprintf(1," acc");
if (Qpot) dprintf(1," pot");
if (Qaux) dprintf(1," aux");
if (Qkey) dprintf(1," key");
if (Qdens) dprintf(1," dens");
if (Qeps) dprintf(1," eps");
dprintf(1,"\n");
if (Qmass || Qphase || Qacc || Qpot || Qaux || Qkey || Qdens || Qeps) {
for (bp = btab; bp < btab+nbody; bp++) {
if(Qmass) Mass(bp) *= mscale;
if(Qphase) {
SMULVV(Pos(bp),rscale);
SMULVV(Vel(bp),vscale);
}
if(Qpot) Phi(bp) *= pscale;
if(Qacc) {
SMULVV(Acc(bp),ascale);
}
if(Qaux) Aux(bp) *= xscale;
if(Qkey) Key(bp) *= kscale;
if(Qdens) Dens(bp) *= dscale;
if(Qeps) Eps(bp) *= escale;
}
} else {
warning("No scaling applied to snapshot");
}
put_snap(outstr, &btab, &nbody, &tsnap, &bits);
}
}
// Turns LLL tree into tree of code fragments
programData opcodeify(Node node,
programAux aux=Aux(),
programVerticalAux vaux=verticalAux()) {
std::string symb = "_"+mkUniqueToken();
Metadata m = node.metadata;
// Numbers
if (node.type == TOKEN) {
return pd(aux, nodeToNumeric(node), 1);
}
else if (node.val == "ref" || node.val == "get" || node.val == "set") {
std::string varname = node.args[0].val;
// Determine reference to variable
if (!aux.vars.count(node.args[0].val)) {
aux.vars[node.args[0].val] = utd(aux.nextVarMem);
aux.nextVarMem += 32;
}
Node varNode = tkn(aux.vars[varname], m);
//std::cerr << varname << " " << printSimple(varNode) << "\n";
// Set variable
if (node.val == "set") {
programData sub = opcodeify(node.args[1], aux, vaux);
if (!sub.outs)
err("Value to set variable must have nonzero arity!", m);
// What if we are setting a stack variable?
if (vaux.dupvars.count(node.args[0].val)) {
int h = vaux.height - vaux.dupvars[node.args[0].val];
if (h > 16) err("Too deep for stack variable (max 16)", m);
Node nodelist[] = {
sub.code,
token("SWAP"+unsignedToDecimal(h), m),
token("POP", m)
};
return pd(sub.aux, multiToken(nodelist, 3, m), 0);
}
// Setting a memory variable
else {
Node nodelist[] = {
sub.code,
varNode,
token("MSTORE", m),
};
return pd(sub.aux, multiToken(nodelist, 3, m), 0);
}
}
// Get variable
else if (node.val == "get") {
// Getting a stack variable
if (vaux.dupvars.count(node.args[0].val)) {
int h = vaux.height - vaux.dupvars[node.args[0].val];
if (h > 16) err("Too deep for stack variable (max 16)", m);
return pd(aux, token("DUP"+unsignedToDecimal(h)), 1);
}
// Getting a memory variable
else {
Node nodelist[] =
{ varNode, token("MLOAD", m) };
return pd(aux, multiToken(nodelist, 2, m), 1);
}
}
// Refer variable
else if (node.val == "ref") {
if (vaux.dupvars.count(node.args[0].val))
err("Cannot ref stack variable!", m);
return pd(aux, varNode, 1);
}
}
// Comments do nothing
else if (node.val == "comment") {
return pd(aux, astnode("_", m), 0);
}
// Custom operation sequence
// eg. (ops bytez id msize swap1 msize add 0 swap1 mstore) == alloc
if (node.val == "ops") {
std::vector<Node> subs2;
int depth = 0;
for (unsigned i = 0; i < node.args.size(); i++) {
std::string op = upperCase(node.args[i].val);
if (node.args[i].type == ASTNODE || opinputs(op) == -1) {
programVerticalAux vaux2 = vaux;
vaux2.height = vaux.height - i - 1 + node.args.size();
programData sub = opcodeify(node.args[i], aux, vaux2);
aux = sub.aux;
depth += sub.outs;
subs2.push_back(sub.code);
}
else {
subs2.push_back(token(op, m));
depth += opoutputs(op) - opinputs(op);
}
}
if (depth < 0 || depth > 1) err("Stack depth mismatch", m);
return pd(aux, astnode("_", subs2, m), 0);
}
// Code blocks
if (node.val == "lll" && node.args.size() == 2) {
if (node.args[1].val != "0") aux.allocUsed = true;
std::vector<Node> o;
o.push_back(finalize(opcodeify(node.args[0])));
programData sub = opcodeify(node.args[1], aux, vaux);
Node code = astnode("____CODE", o, m);
Node nodelist[] = {
token("$begincode"+symb+".endcode"+symb, m), token("DUP1", m),
token("$begincode"+symb, m), sub.code, token("CODECOPY", m),
token("$endcode"+symb, m), token("JUMP", m),
token("~begincode"+symb, m), code,
token("~endcode"+symb, m), token("JUMPDEST", m)
};
return pd(sub.aux, multiToken(nodelist, 11, m), 1);
}
// Stack variables
if (node.val == "with") {
programData initial = opcodeify(node.args[1], aux, vaux);
programVerticalAux vaux2 = vaux;
vaux2.dupvars[node.args[0].val] = vaux.height;
vaux2.height += 1;
if (!initial.outs)
err("Initial variable value must have nonzero arity!", m);
programData sub = opcodeify(node.args[2], initial.aux, vaux2);
Node nodelist[] = {
initial.code,
sub.code
};
programData o = pd(sub.aux, multiToken(nodelist, 2, m), sub.outs);
if (sub.outs)
o.code.args.push_back(token("SWAP1", m));
o.code.args.push_back(token("POP", m));
return o;
}
// Seq of multiple statements
if (node.val == "seq") {
std::vector<Node> children;
int lastOut = 0;
for (unsigned i = 0; i < node.args.size(); i++) {
programData sub = opcodeify(node.args[i], aux, vaux);
aux = sub.aux;
if (sub.outs == 1) {
if (i < node.args.size() - 1) sub.code = popwrap(sub.code);
else lastOut = 1;
}
children.push_back(sub.code);
}
return pd(aux, astnode("_", children, m), lastOut);
}
// 2-part conditional (if gets rewritten to unless in rewrites)
else if (node.val == "unless" && node.args.size() == 2) {
programData cond = opcodeify(node.args[0], aux, vaux);
programData action = opcodeify(node.args[1], cond.aux, vaux);
aux = action.aux;
if (!cond.outs) err("Condition of if/unless statement has arity 0", m);
if (action.outs) action.code = popwrap(action.code);
Node nodelist[] = {
cond.code,
token("$endif"+symb, m), token("JUMPI", m),
action.code,
token("~endif"+symb, m), token("JUMPDEST", m)
};
return pd(aux, multiToken(nodelist, 6, m), 0);
}
// 3-part conditional
else if (node.val == "if" && node.args.size() == 3) {
programData ifd = opcodeify(node.args[0], aux, vaux);
programData thend = opcodeify(node.args[1], ifd.aux, vaux);
programData elsed = opcodeify(node.args[2], thend.aux, vaux);
aux = elsed.aux;
if (!ifd.outs)
err("Condition of if/unless statement has arity 0", m);
// Handle cases where one conditional outputs something
// and the other does not
int outs = (thend.outs && elsed.outs) ? 1 : 0;
if (thend.outs > outs) thend.code = popwrap(thend.code);
if (elsed.outs > outs) elsed.code = popwrap(elsed.code);
Node nodelist[] = {
ifd.code,
token("ISZERO", m),
token("$else"+symb, m), token("JUMPI", m),
thend.code,
token("$endif"+symb, m), token("JUMP", m),
token("~else"+symb, m), token("JUMPDEST", m),
elsed.code,
token("~endif"+symb, m), token("JUMPDEST", m)
};
return pd(aux, multiToken(nodelist, 12, m), outs);
}
// While (rewritten to this in rewrites)
else if (node.val == "until") {
programData cond = opcodeify(node.args[0], aux, vaux);
programData action = opcodeify(node.args[1], cond.aux, vaux);
aux = action.aux;
if (!cond.outs)
err("Condition of while/until loop has arity 0", m);
if (action.outs) action.code = popwrap(action.code);
Node nodelist[] = {
token("~beg"+symb, m), token("JUMPDEST", m),
cond.code,
token("$end"+symb, m), token("JUMPI", m),
action.code,
token("$beg"+symb, m), token("JUMP", m),
token("~end"+symb, m), token("JUMPDEST", m),
};
return pd(aux, multiToken(nodelist, 10, m));
}
// Memory allocations
else if (node.val == "alloc") {
programData bytez = opcodeify(node.args[0], aux, vaux);
aux = bytez.aux;
if (!bytez.outs)
err("Alloc input has arity 0", m);
aux.allocUsed = true;
Node nodelist[] = {
bytez.code,
token("MSIZE", m), token("SWAP1", m), token("MSIZE", m),
token("ADD", m),
token("0", m), token("SWAP1", m), token("MSTORE", m)
};
return pd(aux, multiToken(nodelist, 8, m), 1);
}
// All other functions/operators
else {
std::vector<Node> subs2;
int depth = opinputs(upperCase(node.val));
if (depth == -1)
err("Not a function or opcode: "+node.val, m);
if ((int)node.args.size() != depth)
err("Invalid arity for "+node.val, m);
for (int i = node.args.size() - 1; i >= 0; i--) {
programVerticalAux vaux2 = vaux;
vaux2.height = vaux.height - i - 1 + node.args.size();
programData sub = opcodeify(node.args[i], aux, vaux2);
aux = sub.aux;
if (!sub.outs)
err("Input "+unsignedToDecimal(i)+" has arity 0", sub.code.metadata);
subs2.push_back(sub.code);
}
subs2.push_back(token(upperCase(node.val), m));
int outdepth = opoutputs(upperCase(node.val));
return pd(aux, astnode("_", subs2, m), outdepth);
}
}
programData pd(programAux aux = Aux(), Node code=token("_")) {
programData o;
o.aux = aux;
o.code = code;
return o;
}
// Turns LLL tree into tree of code fragments
programData opcodeify(Node node, programAux aux=Aux()) {
std::string symb = "_"+mkUniqueToken();
Metadata m = node.metadata;
// Numbers
if (node.type == TOKEN) {
return pd(aux, nodeToNumeric(node));
}
else if (node.val == "ref" || node.val == "get" || node.val == "set") {
std::string varname = node.args[0].val;
if (!aux.vars.count(varname)) {
aux.vars[varname] = intToDecimal(aux.vars.size() * 32);
}
if (varname == "msg.data") aux.calldataUsed = true;
// Set variable
if (node.val == "set") {
programData sub = opcodeify(node.args[1], aux);
Node nodelist[] = {
sub.code,
token(aux.vars[varname], m),
token("MSTORE", m),
};
return pd(sub.aux, multiToken(nodelist, 3, m));
}
// Get variable
else if (node.val == "get") {
Node nodelist[] =
{ token(aux.vars[varname], m), token("MLOAD", m) };
return pd(aux, multiToken(nodelist, 2, m));
}
// Refer variable
else return pd(aux, token(aux.vars[varname], m));
}
// Code blocks
if (node.val == "lll" && node.args.size() == 2) {
if (node.args[1].val != "0") aux.allocUsed = true;
std::vector<Node> o;
o.push_back(finalize(opcodeify(node.args[0])));
programData sub = opcodeify(node.args[1], aux);
Node code = astnode("____CODE", o, m);
Node nodelist[] = {
token("$begincode"+symb+".endcode"+symb, m), token("DUP", m),
token("$begincode"+symb, m), sub.code, token("CODECOPY", m),
token("$endcode"+symb, m), token("JUMP", m),
token("~begincode"+symb, m), code, token("~endcode"+symb, m)
};
return pd(sub.aux, multiToken(nodelist, 10, m));
}
std::vector<Node> subs;
for (unsigned i = 0; i < node.args.size(); i++) {
programData sub = opcodeify(node.args[i], aux);
aux = sub.aux;
subs.push_back(sub.code);
}
// Debug
if (node.val == "debug") {
Node nodelist[] = {
subs[0],
token("DUP", m), token("POP", m), token("POP", m)
};
return pd(aux, multiToken(nodelist, 4, m));
}
// Seq of multiple statements
if (node.val == "seq") {
return pd(aux, astnode("_", subs, m));
}
// 2-part conditional (if gets rewritten to unless in rewrites)
else if (node.val == "unless" && node.args.size() == 2) {
Node nodelist[] = {
subs[0],
token("$endif"+symb, m), token("JUMPI", m),
subs[1],
token("~endif"+symb, m)
};
return pd(aux, multiToken(nodelist, 5, m));
}
// 3-part conditional
else if (node.val == "if" && node.args.size() == 3) {
Node nodelist[] = {
subs[0],
token("NOT", m), token("$else"+symb, m), token("JUMPI", m),
subs[1],
token("$endif"+symb, m), token("JUMP", m), token("~else"+symb, m),
subs[2],
token("~endif"+symb, m)
};
return pd(aux, multiToken(nodelist, 10, m));
}
// While (rewritten to this in rewrites)
else if (node.val == "until") {
Node nodelist[] = {
token("~beg"+symb, m),
subs[0],
token("$end"+symb, m), token("JUMPI", m),
subs[1],
token("$beg"+symb, m), token("JUMP", m), token("~end"+symb, m)
};
return pd(aux, multiToken(nodelist, 8, m));
}
// Memory allocations
else if (node.val == "alloc") {
aux.allocUsed = true;
Node nodelist[] = {
subs[0],
token("MSIZE", m), token("SWAP", m), token("MSIZE", m),
token("ADD", m),
token("0", m), token("SWAP", m), token("MSTORE", m)
};
return pd(aux, multiToken(nodelist, 8, m));
}
// Array literals
else if (node.val == "array_lit") {
aux.allocUsed = true;
std::vector<Node> nodes;
if (!subs.size()) {
nodes.push_back(token("MSIZE", m));
return pd(aux, astnode("_", nodes, m));
}
nodes.push_back(token("MSIZE", m));
nodes.push_back(token("0", m));
nodes.push_back(token("MSIZE", m));
nodes.push_back(token(intToDecimal(subs.size() * 32 - 1), m));
nodes.push_back(token("ADD", m));
nodes.push_back(token("MSTORE8", m));
for (unsigned i = 0; i < subs.size(); i++) {
nodes.push_back(token("DUP", m));
nodes.push_back(subs[i]);
nodes.push_back(token("SWAP", m));
if (i > 0) {
nodes.push_back(token(intToDecimal(i * 32), m));
nodes.push_back(token("ADD", m));
}
nodes.push_back(token("MSTORE", m));
}
return pd(aux, astnode("_", nodes, m));
}
// All other functions/operators
else {
std::vector<Node> subs2;
while (subs.size()) {
subs2.push_back(subs.back());
subs.pop_back();
}
subs2.push_back(token(upperCase(node.val), m));
return pd(aux, astnode("_", subs2, m));
}
}
