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