TEST(MoveListTest, Assignement)
{
MoveList moves;
Move m;
for (int i = 0; i < MAX_PLY; ++i) {
for (int j = 0; j < MAX_MOVES; ++j) {
ExtendedMove em1(m, i + j);
moves[j] = em1;
EXPECT_EQ(em1, moves[j]);
EXPECT_EQ(em1.value(), moves[j].value());
}
moves.inc_ply();
}
for (int i = MAX_PLY - 1; i > 0; --i) {
moves.dec_ply();
for (int j = 0; j < MAX_MOVES; ++j) {
ExtendedMove em1(m, i + j);
EXPECT_EQ(em1, moves[j]);
EXPECT_EQ(em1.value(), moves[j].value());
}
}
moves.clear();
for (int i = 0; i < MAX_PLY; ++i) {
for (int j = 0; j < MAX_MOVES; ++j) {
ExtendedMove em1(m, i + j);
EXPECT_EQ(em1, moves[j]);
EXPECT_EQ(em1.value(), moves[j].value());
}
moves.inc_ply();
}
}
obj Map(obj vi){
if(type(vi)!=LIST) error("map: needs two arguments.");
obj fn = em0(vi);
obj v = em1(vi);
if(!(type(fn)==tClosure || type(fn)==tInternalFn)) error("map: first arg must be a function");
switch(type(v)){
case LIST:
case ARITH:{
list r = nil;
for(list l=ul(v); l; l=rest(l)){
r = cons(eval_function(fn, retain(first(l))), r);
}
return render(type(v), reverse(r));
}
case tDblArray:
case tIntArr:
case tArray: {
int len = size(v);
obj rr = aArray(len);
for(int i=0; i<len; i++){
obj arg = ind(v,i);
uar(rr).v[i] = eval_function(fn, arg);
// release(arg);
}
return rr;
} default:
error("map: second arg must be a list or an array.");
return nil;
}
}
obj eval_curry(obj exp, obj vars) { // envÇÕǢNjé¿çsíÜÇÃ
/* push(env);
env = op(vars, nil);
obj rr = exec(em1(exp));
pop(&env);
env = pop(&is);
return strip_return(rr);
/*/ env = op(vars, env);
obj rr = exec(em1(exp));
pop(&env);
return strip_return(rr);
/**/}
int main(){
// Test suite1.
Employee em1("박철수","경리");
em1.doWork();
em1.doWork();
em1.doWork();
em1.doWork();
em1.goVacation();
em1.receiveSalary();
return 0;
}
static
obj enclose(obj v){
vto_close = Assoc();
assert(v->type == tArrow);
obj vs = Assoc();
pbind_vars(&vs, em0(v));
penv = op(vs, nil);
enclose0(em1(v));
release(penv);
assert(vto_close->type == tAssoc);
if(! ul(vto_close)) return render(tClosure, list3(retain(em0(v)), retain(em1(v)), nil));
list varlist = nil, vallist = nil;
for(list l = ul(vto_close); l; l=rest(l)){
varlist = cons(retain(car(first(l))), varlist);
vallist = cons(find_var(car(first(l))), vallist);
}
release(vto_close);
obj rr = curry(List2v(varlist), List2v(vallist), retain(em1(v)));
rr = render(tClosure, list3(retain(em0(v)), rr, nil));
return rr;
}
void Init(FileArchive archive){
font = Font(30, L"Yu Gothic");
EvaluationMap1=std::vector<std::vector<int>>(8, std::vector<int>(8));
CSVReader em1(archive.load(L"EvaluationMap1.csv"));
if (!em1)
{
return;
}
int Rows = em1.rows;
int Columns = em1.columns(0);
for (int i = 0; i < em1.rows; i++){
for (int j = 0; j < em1.columns(i);j++){
EvaluationMap1[i][j] = em1.get<int>(i, j);
}
}
}
int main_1dsfs(int argc,char **argv){
if(argc<2){
fprintf(stderr,"Must supply afile.saf and number of chromosomes\n");
return 0;
}
fname1 = *(argv++);
chr1 = atoi(*(argv++));
argc-=2;
getArgs(argc,argv);
dim=chr1+1;
//hook for new EJ banded version
if(isNewFormat(fname1))
return main_1dsfs_v2(fname1,chr1,nSites,nThreads,sfsfname,tole,maxIter);
if(nSites==0){//if no -nSites is specified
if(fsize(fname1)>getTotalSystemMemory())
fprintf(stderr,"Looks like you will allocate too much memory, consider starting the program with a lower -nSites argument\n");
//this doesnt make sense if ppl supply a filelist containing safs
nSites=calcNsites(fname1,chr1);
}
fprintf(stderr,"fname1:%s nChr:%d startsfs:%s nThreads:%d tole=%f maxIter=%d nSites=%lu\n",fname1,chr1,sfsfname,nThreads,tole,maxIter,nSites);
float bytes_req_megs = nSites*(sizeof(double)*(chr1+1)+sizeof(double*))/1024/1024;
float mem_avail_megs = getTotalSystemMemory()/1024/1024;//in percentile
// fprintf(stderr,"en:%zu to:%f\n",bytes_req_megs,mem_avail_megs);
fprintf(stderr,"The choice of -nSites will require atleast: %f megabyte memory, that is approx: %.2f%% of total memory\n",bytes_req_megs,bytes_req_megs*100/mem_avail_megs);
Matrix<double> GL1=alloc(nSites,dim);
gzFile gz1=getGz(fname1);
double *sfs=new double[dim];
while(1) {
if(isList==0)
readGL(gz1,nSites,chr1,GL1);
else
readGL2(gz1,nSites,chr1,GL1);
if(GL1.x==0)
break;
fprintf(stderr,"dim(GL1)=%zu,%zu\n",GL1.x,GL1.y);
if(sfsfname!=NULL){
readSFS(sfsfname,dim,sfs);
}else{
for(int i=0;i<dim;i++)
sfs[i] = (i+1)/((double)dim);
if(doBFGS){
double ts=1;
for(int i=0;i<dim-1;i++)
ts += 0.01/(1.0+i);
sfs[0]=1.0/ts;
for(int i=0;i<dim-1;i++)
sfs[i+1] = (0.01/(1.0+i))/ts;
}
normalize(sfs,dim);
}
// em2_smart(sfs2,pops,1e-6,1e3);
setThreadPars(&GL1,NULL,sfs,nThreads);
if(calcLike==0){
if(doBFGS==0)
em1(sfs,&GL1,tole,maxIter);
else
bfgs(sfs,&GL1);
}
double lik;
if(nThreads>1)
lik = lik1_master();
else
lik = lik1(sfs,&GL1,0,GL1.x);
fprintf(stderr,"likelihood: %f\n",lik);
#if 1
for(int x=0;x<dim;x++)
fprintf(stdout,"%f ",log(sfs[x]));
fprintf(stdout,"\n");
fflush(stdout);
#endif
if(isList==1)
break;
}
dalloc(GL1,nSites);
gzclose(gz1);
delete [] sfs;
return 0;
}
obj eval(obj exp){
ev: assert(!! exp);
obj rr,lt, rt;
switch (exp->type) {
case tInd:
return doInd(eval(ult(exp)), ul(eval(urt(exp))));
case LIST:
return List2v(evalList(ul(exp)));
case tArray:
return map_obj(eval, exp);
case tAnd:
return prod_eval(ul(exp), mult);
case MULT:
return prod_eval(ul(exp), mult);
case ARITH:
return prod_eval(ul(exp), add);
case POW:
return prod_eval(ul(exp), power);
case DIVIDE:
return prod_eval(ul(exp), divide);
case tRef:
return retain(uref(exp));
case tSymbol:
if( macromode) {
if(obj rr = search_assoc(car(macro_env), exp)){
macromode = false;
// macro lexical scope should be pushed to the stack here
rr = exec(rr);
macromode = true;
return rr;
}
}
return eval_symbol(exp);
case tMinus:
lt = eval(uref(exp));
rr = uMinus(lt); // releasing
if(rr) {release(lt); return rr;}
static obj symumn = Symbol("-");
rr = udef_op0(symumn, lt);
if(rr) {release(lt); return rr;}
error("uMinus: not defined to that type");
case tReturn:
if(! uref(exp)) return encap(tSigRet, nil);
return encap(tSigRet, eval(uref(exp)));
case tBreak:
return retain(exp);
case CONDITION:
return evalCond(exp);
case tOp:
if(type(ult(exp)) ==tSymbol) {
lt = search_assoc(curr_interp->types, ult(exp));
if(lt) return encap((ValueType)vrInt(lt), eval(urt(exp)));}
lt = eval(ult(exp));
push(lt);
switch(lt->type){
case tCont:
assert(0);
case tSpecial:
rr = ufn(lt)(urt(exp));
break;
case tSyntaxLam:
rr = macro_exec(lt, urt(exp));
break;
case tInternalFn:
case tClosure:
rt = eval(urt(exp));
rr = eval_function(lt, rt);
break;
default:
rt = eval(urt(exp));
rr = call_fn(mult, lt, rt);
release(rt);
}
release(pop(&is));
return rr;
case tClosure:
assert(0);
case tCurry:
return eval_curry(exp, em0(exp));
/* obj vars = Assoc();
bind_vars(&vars, em0(exp), em2(exp));
rr = eval_curry(exp, vars);
release(vars);
return rr;
*/ case tArrow:
// return enclose(exp);
/* if(macromode){
if(obj rr = search_assoc(car(macro_env), exp)){
}
}
*/ return render(tClosure, list3(retain(em0(exp)), retain(em1(exp)), retain(env)));
case tDefine:
return func_def(em0(exp), em1(exp), em2(exp));
case tSyntaxDef:
let(lfind_var(em0(exp)), render(tSyntaxLam, list3(retain(em1(exp)), retain(em2(exp)), nil)));
return nil;
case tExec:
return exec(exp);
case tAssign:
lt = car(exp);
if(type(lt)==tOp){
return func_def(ult(lt), urt(lt), cdr(exp));
} else if(type(lt)==tMinus){
static obj symumn = Symbol("-");
return func_def(symumn, uref(lt), cdr(exp));
} else return do_assign(lt, eval(cdr(exp)));
case tIf:
rr = eval(em0(exp));
if (type(rr) != INT) error("if: Boolean Expected");
if (vrInt(rr)) {
rr = em1(exp);
} else {
rr = em2(exp);
}
return eval(rr);
case tWhile:
for(;;) {
rr = eval(car(exp));
if (type(rr) != INT) error("while: Boolean expected");
if(!vrInt(rr)) break;
rr = exec(cdr(exp));
if(rr && type(rr)==tSigRet) return rr;
if(rr && type(rr)==tBreak) {release(rr); break;}
if(rr) release(rr);
}
return nil;
default:
return retain(exp);
}
}
static
void enclose0(obj v){
assert(!! v);
switch(v->type){
case tSymbol:
/* if( macromode) {
for(obj e = macro_env; e; e = cdr(e)){
obj rr = search_assoc(car(e), v);
if (v) { rr = v; break;}
}
//if(obj rr = search_assoc(car(macro_env), v)){ v=rr;}
}
//*/ if(is_in(penv, v)) return;
if(search_pair(vto_close, car(v))) return;
add_assoc(&vto_close, v, nil);
return;
case tAssign:
enclose0(cdr(v));
if(is_in(penv, car(v))) return;
if(search_pair(vto_close, car(v))) return;
if(is_in(env, car(v))) {
add_assoc(&vto_close, car(v), nil);
return;
}
add_assoc(&car(penv), car(v), nil); // new assignment
return;
case tClosure:
assert(0);
case tArrow:{
obj vs = Assoc();
pbind_vars(&vs, em0(v));
penv = op(vs, penv);
enclose0(em1(v));
release(pop(&penv));
return;
}
case tDefine:
case tSyntaxDef:
assert(0);
case tArray:
for(int i=0; i < uar(v).size; i++) enclose0(uar(v).v[i]);
return;
case LIST: //list
case POW:
case MULT:
case DIVIDE:
case ARITH:
case CONDITION:
case tIf:
case tExec:
case tAnd:
for(list s=ul(v); s; s=rest(s)) enclose0(first(s));
return;
case tReturn:
if(!uref(v)) return;
case tMinus:
enclose0(uref(v));
return;
case tInd:
case tWhile:
case tOp:
enclose0(car(v));
enclose0(cdr(v));
return;
case INT:
case tDouble:
case TOKEN:
case tNull:
case tLAVec:
case tDblArray:
case tIntArr:
case tDblAr2:
case IMAGE:
case STRING:
case tBreak:
return;
default:
break;
}
print(v);
assert(0);
return;
}
obj subs0(obj v, obj * vars){
assert(!! v);
switch(v->type){
case tSymbol:
if(vars){ // macro
obj vp = search_assoc(*vars, v);
if(vp) return vp;
// vp = searchFunc(v, specials);
// if(vp) {release(vp); return retain(v);}
obj (*func)(obj) = searchFunc(v, specials);
if(func) return retain(v);
vp = find_var(v);
if(vp) {release(vp); return retain(v);}
assert(0);
// return ref2var(add_assoc(*vars, v, Null()));
} else { // quasi-quote
obj vp = find_var(v);
if(vp) return vp;
return retain(v);
}
case tAssign:{
obj vp = search_assoc(*vars, car(v)); //macro-locals
if(vp) goto nex;
/* vp = searchFunc(car(v), specials); // not needed because cant assign to global
if(vp) {release(vp); vp = retain(v); return vp;}
vp = find_var(v);
if(vp) {release(vp); vp = retain(v); return vp;}
*/ vp = ref2var(nil);
add_assoc(vars, car(v), vp);
nex: return operate(tAssign, vp, subs0(cdr(v), vars));
}
case tArray:{
obj r = aArray(uar(v).size);
for(int i=0; i < uar(v).size; i++) uar(r).v[i] = subs0(uar(v).v[i], vars);
return r;
}
case LIST: //list
case POW:
case MULT:
case DIVIDE:
case ARITH:
case CONDITION:
case tIf:
case tExec:
{
list l = phi();
for(list s=ul(v); s; s=rest(s)) l = cons(subs0(first(s), vars), l);
return render(type(v), reverse(l));
}
case tReturn:
if(!uref(v)) return retain(v);
case tMinus:
return encap(v->type, subs0(uref(v), vars));
case tClosure:
case tArrow:
return render(type(v), list3(subs0(em0(v),vars), subs0(em1(v), vars), nil));
case tDefine:
case tSyntaxDef:
assert(0);
case tInd:
case tWhile:
{
obj st = subs0(cdr(v), vars);
if(type(st)==LIST) st->type = tExec;
return operate(v->type, subs0(car(v), vars), st);
}
case tOp:
return operate(v->type, subs0(car(v), vars), subs0(cdr(v), vars));
case INT:
case tDouble:
case TOKEN:
case tNull:
case tLAVec:
case tDblArray:
case tIntArr:
case tDblAr2:
case IMAGE:
case STRING:
case tBreak:
return retain(v);
default:
break;
}
print(v);
assert(0);
return v;
}
