// Constructor
TruncatedCG( Teuchos::ParameterList &parlist ) : TrustRegion<Real>(parlist), pRed_(0) {
// Unravel Parameter List
Real em4(1e-4), em2(1e-2);
maxit_ = parlist.sublist("General").sublist("Krylov").get("Iteration Limit",20);
tol1_ = parlist.sublist("General").sublist("Krylov").get("Absolute Tolerance",em4);
tol2_ = parlist.sublist("General").sublist("Krylov").get("Relative Tolerance",em2);
}
inline Teuchos::RCP<Krylov<Real> > KrylovFactory( Teuchos::ParameterList &parlist ) {
Real em4(1e-4), em2(1e-2);
EKrylov ekv = StringToEKrylov(
parlist.sublist("General").sublist("Krylov").get("Type","Conjugate Gradients"));
Real absTol = parlist.sublist("General").sublist("Krylov").get("Absolute Tolerance", em4);
Real relTol = parlist.sublist("General").sublist("Krylov").get("Relative Tolerance", em2);
int maxit = parlist.sublist("General").sublist("Krylov").get("Iteration Limit", 20);
bool inexact = parlist.sublist("General").get("Inexact Hessian-Times-A-Vector",false);
switch(ekv) {
case KRYLOV_CR:
return Teuchos::rcp( new ConjugateResiduals<Real>(absTol,relTol,maxit,inexact) );
case KRYLOV_CG:
return Teuchos::rcp( new ConjugateGradients<Real>(absTol,relTol,maxit,inexact) );
case KRYLOV_GMRES:
return Teuchos::rcp( new GMRES<Real>(parlist) );
default: return Teuchos::null;
}
}
int main_2dsfs(int argc,char **argv){
if(argc==1){
fprintf(stderr,"./emOptim2 2dsfs pop1 pop2 nChr1 nChr2 [-start FNAME -P nThreds -tole tole -maxIter ] (only works if the two saf files covers the same region)\n");
return 0;
}
argv++;
argc--;
fname1 = *(argv++);
fname2 = *(argv++);
argc -=2;
chr1 = atoi(*(argv++));
chr2 = atoi(*(argv++));
argc -=2;
getArgs(argc,argv);
if(nSites==0){
if(fsize(fname1)+fsize(fname2)>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:%sfname2:%s chr1:%d chr2:%d startsfs:%s nThreads=%d tole=%f maxIter=%d nSites:%lu\n",fname1,fname2,chr1,chr2,sfsfname,nThreads,tole,maxIter,nSites);
float bytes_req_megs = nSites*(sizeof(double)*(chr1+1) + sizeof(double)*(chr2+1)+2*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);
#if 0
//read in positions, not used, YET...
std::vector<int> p1 = getPosi(fname1);
std::vector<int> p2 = getPosi(fname2);
fprintf(stderr,"nSites in pop1: %zu nSites in pop2: %zu\n",p1.size(),p2.size());
#endif
if(nSites==0){
if(calcNsites(fname1,chr1)!=calcNsites(fname2,chr2)){
fprintf(stderr,"Problem with number of sites in file: %s and %s\n",fname1,fname2);
exit(0);
}
nSites=calcNsites(fname1,chr1);
}
gzFile gz1=getGz(fname1);
gzFile gz2=getGz(fname2);
dim=(chr1+1)*(chr2+1);
Matrix<double> GL1=alloc(nSites,chr1+1);
Matrix<double> GL2=alloc(nSites,chr2+1);
dim=GL1.y*GL2.y;
double *sfs = new double[dim];
while(1){
if(isList ==0){
readGL(gz1,nSites,chr1,GL1);
readGL(gz2,nSites,chr2,GL2);
}else{
readGL2(gz1,nSites,chr1,GL1);
readGL2(gz2,nSites,chr2,GL2);
}
assert(GL1.x==GL2.x);
if(GL1.x==0)
break;
if(sfsfname!=NULL){
readSFS(sfsfname,dim,sfs);
}else{
for(int i=0;i<dim;i++)
sfs[i] = (i+1)/((double)dim);
normalize(sfs,dim);
}
setThreadPars(&GL1,&GL2,sfs,nThreads);
if(calcLike==0){
if(SIG_COND)
em2(sfs,&GL1,&GL2,tole,maxIter);
}
double lik;
if(nThreads>1)
lik = lik1_master();
else
lik = lik1(sfs,&GL1,0,GL1.x);
fprintf(stderr,"likelihood: %f\n",lik);
#if 1
int inc=0;
for(int x=0;x<chr1+1;x++){
for(int y=0;y<chr2+1;y++)
fprintf(stdout,"%f ",log(sfs[inc++]));
fprintf(stdout,"\n");
}
#endif
if(isList==1)
break;
}
dalloc(GL1,nSites);
dalloc(GL2,nSites);
gzclose(gz1);
gzclose(gz2);
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);
}
}
