void plot_diff_xsec() { TF1* fXsec = new TF1("fXsec", "diff_xsec(x)", 1, 0); fXsec->SetLineWidth(3); fXsec->SetTitle("#nu_{#mu}-e differential cross section (E_{#nu} = 2 GeV)"); fXsec->Draw(); fXsec->GetXaxis()->SetTitle("cos#theta"); fXsec->GetXaxis()->CenterTitle(); fXsec->GetYaxis()->SetTitle("d#sigma/dcos#theta (cm^{-2})"); fXsec->GetYaxis()->CenterTitle(); fXsec->GetYaxis()->SetTitleOffset(1.4); gPad->SetLogy(1); double totXsec = fXsec->Integral(0,1); for(int i = 0; i < 100; i++) { cout << fXsec->Integral(0.01*i,1)/totXsec << endl; } cout << totXsec << " " << fXsec->Integral(.99,1) << endl; ROOT::Math::GSLIntegrator ig(1.E-6,1.E-6,1000); ROOT::Math::WrappedTF1 wf(*fXsec); ig.SetFunction(wf); cout << ig.Integral(.9,1) << endl; //~ TCanvas* c2 = new TCanvas("c2"); //~ TF1* fCXsec = new TF1("fCXsec", "cumul_xsec(x)", 0, 90); //~ fCXsec->Draw(); //~ cout << cumul_xsec(45) << endl; }
int main(int argc, char** argv) { if (argc != 3) { std::cerr << argv[0] << " [gold file] [test file]" << std::endl; return 1; } trance::Tree gold; trance::Tree test; trance::Evalb evalb; trance::EvalbScorer scorer; utils::compress_istream ig(argv[1]); utils::compress_istream it(argv[2]); for (;;) { ig >> gold; it >> test; if (! ig || ! it) break; scorer.assign(gold); evalb += scorer(test); } if (ig || it) throw std::runtime_error("# of trees does not match"); std::cout << "scor: " << evalb() << " match: " << evalb.match_ << " gold: " << evalb.gold_ << " test: " << evalb.test_<< std::endl; }
double LEP2sigmaMu::computeThValue() { Mw = SM.Mw(); GammaZ = SM.Gamma_Z(); if (!checkSMparams(s, Mw, GammaZ)) { ml_cache = m_l(SM.MU); if (!flag[ISR]) SMresult_cache = sigma_NoISR_l(); else { ROOT::Math::Functor1D wf(this, &LEP2sigmaMu::Integrand_sigmaWithISR_l); ROOT::Math::Integrator ig(wf, ROOT::Math::IntegrationOneDim::kADAPTIVESINGULAR); ig.SetAbsTolerance(1.E-14); // desired absolute error ig.SetRelTolerance(1.E-4); // desired relative error SMresult_cache = ig.Integral(0.0, 1.0-0.85*0.85); // interval /* check MathMore library is required to use kADAPTIVESINGULAR. */ //std::cout << ig.Options().Integrator() << std::endl; //std::cout << ig.Options().AbsTolerance() << std::endl; //std::cout << ig.Options().RelTolerance() << std::endl; //std::cout << SMresult_cache << " +- " << ig.Error() << std::endl; // results: 6.8e-9 -- 2.2e-8 } if (flag[WeakBox]) { ROOT::Math::Functor1D wf_box(this, &LEP2sigmaMu::Integrand_dsigmaBox_l); ROOT::Math::Integrator ig_box(wf_box, ROOT::Math::IntegrationOneDim::kADAPTIVESINGULAR); ig_box.SetAbsTolerance(1.E-17); // desired absolute error ig_box.SetRelTolerance(1.E-4); // desired relative error double sigma_box = ig_box.Integral(-1.0, 1.0); // interval SMresult_cache += sigma_box; //std::cout << sigma_box << " +- " << ig_box.Error() << std::endl; // results: 3.5e-12 -- +2.9e-10 } } double sigma_mu = SMresult_cache; #ifdef LEP2TEST sigma_mu = myTEST.sigmaMuTEST(sqrt_s)/SM.GeVminus2_to_nb/1000.0; #endif if ( checkLEP2NP() && !bSigmaForAFB ) { double obliqueShat = (dynamic_cast<const NPSTUVWXY*> (&SM))->obliqueShat(); double obliqueThat = (dynamic_cast<const NPSTUVWXY*> (&SM))->obliqueThat(); double obliqueUhat = (dynamic_cast<const NPSTUVWXY*> (&SM))->obliqueUhat(); double obliqueV = (dynamic_cast<const NPSTUVWXY*> (&SM))->obliqueV(); double obliqueW = (dynamic_cast<const NPSTUVWXY*> (&SM))->obliqueW(); double obliqueX = (dynamic_cast<const NPSTUVWXY*> (&SM))->obliqueX(); double obliqueY = (dynamic_cast<const NPSTUVWXY*> (&SM))->obliqueY(); double ObParam[7] = {obliqueShat, obliqueThat, obliqueUhat, obliqueV, obliqueW, obliqueX, obliqueY}; sigma_mu += myLEP2oblique.sigma_l_LEP2_NP(StandardModel::MU, s, ml_cache, ObParam); } return ( sigma_mu*SM.GeVminus2_to_nb*1000.0 ); }
static int innards(int iconlabel, const char *istr, int itype, const char* fmt, va_list ap, const char *b0, const char *b1, const char *b2) { Fl_Window window(3*BORDER_W+ICON_W+INPUT_W, 3*BORDER_H+ICON_H+BUTTON_H); // This keeps the icon from resizing. Fl_Group ig(BORDER_W, BORDER_H, ICON_W, ICON_H); Fl_Box icon(0, 0, ICON_W, ICON_H); if (iconlabel==0) { icon.image(information_pix); window.label(_("Information")); } else if (iconlabel==1) { icon.image(warning_pix); window.label(_("Warning")); } else { icon.image(information_pix); window.label(_("Question")); } ig.end(); Fl_Box message(2*BORDER_W+ICON_W, 0, INPUT_W, 2*BORDER_H+ICON_H); message.set_flag(FL_ALIGN_LEFT|FL_ALIGN_INSIDE|FL_ALIGN_WRAP); message.style(fl_message_style); if (input) {delete input; input = 0;} if (istr) { input = new Fl_Input(2*BORDER_W+ICON_W, 0, INPUT_W, 0); input->h(input->text_size()+10); input->y(BORDER_H+ICON_H-input->h()); message.h(input->y()); input->type(itype); input->value(istr); window.focus(input); } window.resizable(message); // w->size_range(window.w(), window.h(), 0, window.h()); char buffer[1024] = {0}; if (!strcmp(fmt,"%s")) { message.label(va_arg(ap, const char*)); }
void testIntegPerf(double x1, double x2, int n = 100000){ std::cout << "\n\n***************************************************************\n"; std::cout << "Test integration performances in interval [ " << x1 << " , " << x2 << " ]\n\n"; TStopwatch timer; double dx = (x2-x1)/double(n); //ROOT::Math::Functor1D<ROOT::Math::IGenFunction> f1(& TMath::BreitWigner); ROOT::Math::WrappedFunction<> f1(func); timer.Start(); ROOT::Math::Integrator ig(f1 ); double s1 = 0.0; nc = 0; for (int i = 0; i < n; ++i) { double x = x1 + dx*i; s1+= ig.Integral(x1,x); } timer.Stop(); std::cout << "Time using ROOT::Math::Integrator :\t" << timer.RealTime() << std::endl; std::cout << "Number of function calls = " << nc/n << std::endl; int pr = std::cout.precision(18); std::cout << s1 << std::endl; std::cout.precision(pr); //TF1 *fBW = new TF1("fBW","TMath::BreitWigner(x)",x1, x2); // this is faster but cannot measure number of function calls TF1 *fBW = new TF1("fBW",func2,x1, x2,0); timer.Start(); nc = 0; double s2 = 0; for (int i = 0; i < n; ++i) { double x = x1 + dx*i; s2+= fBW->Integral(x1,x ); } timer.Stop(); std::cout << "Time using TF1::Integral :\t\t\t" << timer.RealTime() << std::endl; std::cout << "Number of function calls = " << nc/n << std::endl; pr = std::cout.precision(18); std::cout << s1 << std::endl; std::cout.precision(pr); }
// to generate the iwts again, and return to Fortran int get_iwts(Mesh &mesh, MEField<> *iwts, int *regridScheme) { // generate integration weights Integrate ig(mesh); // Clear weights ig.clearWeights(iwts); // Add weights to meshes before poles // so all the weights are on user data points if (*regridScheme == ESMC_REGRID_SCHEME_FULL3D) { for (UInt i = 1; i <= 7; ++i) ig.AddPoleWeights(mesh,i,iwts); } // Add in other none-pole weights // (and do cross processor sum) ig.intWeights(iwts); return 1; }
void Gl1_PolyhedraPhys::go(const shared_ptr<IPhys>& ip, const shared_ptr<Interaction>& i, const shared_ptr<Body>& b1, const shared_ptr<Body>& b2, bool wireFrame){ if(!gluQuadric){ gluQuadric=gluNewQuadric(); if(!gluQuadric) throw runtime_error("Gl1_PolyhedraPhys::go unable to allocate new GLUquadric object (out of memory?)."); } PolyhedraPhys* np=static_cast<PolyhedraPhys*>(ip.get()); shared_ptr<IGeom> ig(i->geom); if(!ig) return; // changed meanwhile? PolyhedraGeom* geom=YADE_CAST<PolyhedraGeom*>(ig.get()); Real fnNorm=np->normalForce.dot(geom->normal); if((signFilter>0 && fnNorm<0) || (signFilter<0 && fnNorm>0)) return; int fnSign=fnNorm>0?1:-1; fnNorm=std::abs(fnNorm); Real radiusScale=1.; maxFn=max(fnNorm,maxFn); Real realMaxRadius; if(maxRadius<0){ refRadius=min(0.03,refRadius); realMaxRadius=refRadius; } else realMaxRadius=maxRadius; Real radius=radiusScale*realMaxRadius*(fnNorm/maxFn); if (radius<=0.) radius = 1E-8; Vector3r color=Shop::scalarOnColorScale(fnNorm*fnSign,-maxFn,maxFn); Vector3r p1=b1->state->pos, p2=b2->state->pos; Vector3r relPos; relPos=p2-p1; Real dist=relPos.norm(); glDisable(GL_CULL_FACE); glPushMatrix(); glTranslatef(p1[0],p1[1],p1[2]); Quaternionr q(Quaternionr().setFromTwoVectors(Vector3r(0,0,1),relPos/dist /* normalized */)); // using Transform with OpenGL: http://eigen.tuxfamily.org/dox/TutorialGeometry.html //glMultMatrixd(Eigen::Affine3d(q).data()); glMultMatrix(Eigen::Transform<Real,3,Eigen::Affine>(q).data()); glColor3v(color); gluCylinder(gluQuadric,radius,radius,dist,slices,stacks); glPopMatrix(); }
void DrawCumulative(double x1, double x2, int n = 100){ std::cout << "\n\n***************************************************************\n"; std::cout << "Drawing cumulatives of BreitWigner in interval [ " << x1 << " , " << x2 << " ]\n\n"; double dx = (x2-x1)/double(n); TH1D *cum0 = new TH1D("cum0", "", n, x1, x2); //exact cumulative for (int i = 1; i <= n; ++i) { double x = x1 + dx*i; cum0->SetBinContent(i, exactIntegral(x1, x)); } // alternative method using ROOT::Math::Functor class ROOT::Math::Functor1D f1(& func); ROOT::Math::Integrator ig(f1, ROOT::Math::IntegrationOneDim::kADAPTIVE,1.E-12,1.E-12); TH1D *cum1 = new TH1D("cum1", "", n, x1, x2); for (int i = 1; i <= n; ++i) { double x = x1 + dx*i; cum1->SetBinContent(i, ig.Integral(x1,x)); } TF1 *fBW = new TF1("fBW","TMath::BreitWigner(x, 0, 1)",x1, x2); TH1D *cum2 = new TH1D("cum2", "", n, x1, x2); for (int i = 1; i <= n; ++i) { double x = x1 + dx*i; cum2->SetBinContent(i, fBW->Integral(x1,x)); } TH1D *cum10 = new TH1D("cum10", "", n, x1, x2); //difference between 1 and exact TH1D *cum20 = new TH1D("cum23", "", n, x1, x2); //difference between 2 and excact for (int i = 1; i <= n; ++i) { double delta = cum1->GetBinContent(i) - cum0->GetBinContent(i); double delta2 = cum2->GetBinContent(i) - cum0->GetBinContent(i); //std::cout << " diff for " << x << " is " << delta << " " << cum1->GetBinContent(i) << std::endl; cum10->SetBinContent(i, delta ); cum10->SetBinError(i, std::numeric_limits<double>::epsilon() * cum1->GetBinContent(i) ); cum20->SetBinContent(i, delta2 ); } TCanvas *c1 = new TCanvas("c1","Integration example",20,10,800,500); c1->Divide(2,1); c1->Draw(); cum0->SetLineColor(kBlack); cum0->SetTitle("BreitWigner - the cumulative"); cum0->SetStats(0); cum1->SetLineStyle(2); cum2->SetLineStyle(3); cum1->SetLineColor(kBlue); cum2->SetLineColor(kRed); c1->cd(1); cum0->DrawCopy("h"); cum1->DrawCopy("same"); //cum2->DrawCopy("same"); cum2->DrawCopy("same"); c1->cd(2); cum10->SetTitle("Difference"); cum10->SetStats(0); cum10->SetLineColor(kBlue); cum10->Draw("e0"); cum20->SetLineColor(kRed); cum20->Draw("hsame"); TLegend * l = new TLegend(0.11, 0.8, 0.7 ,0.89); l->AddEntry(cum10, "GSL integration - analytical "); l->AddEntry(cum20, "TF1::Integral - analytical "); l->Draw(); c1->Update(); std::cout << "\n***************************************************************\n"; }
void fitMKVoight(TH1 *h33 , Double_t low, Double_t high, Double_t p0, Double_t p1, Double_t p2, Double_t p3, Double_t initialPar, Double_t width, Double_t Gamma, Double_t factor, Int_t draw_opt){ //double nEnt = h33->GetEntries(); double nEnt = h33->GetMaximum(); double in_par[8] = {100, initialPar, width , Gamma, p0, p1, p2}; //{A,mean,sigma,Gamma} TF1 *fitter = new TF1("fitter",myFuncBWG,low,high,8); fitter->SetParameters(&in_par[0]); fitter->SetParLimits(0,10,nEnt); fitter->SetParLimits(1,initialPar-width,initialPar+width); fitter->SetLineColor(kBlue); h33->Fit("fitter","REM+","same"); //h33->Draw("E"); TF1 *backFcn = new TF1("backFcn", "pol2",low,high); TF1 *signalFcn = new TF1("signalFcn", myVoight,low,high,4); signalFcn->SetLineColor(kBlue); signalFcn->SetLineWidth(2); Double_t par[8]; fitter->GetParameters(par); backFcn->SetParameters(&par[4]); backFcn->SetLineStyle(2); backFcn->SetLineColor(6); backFcn->SetLineWidth(1); signalFcn->SetParameters(par); signalFcn->SetLineStyle(2); signalFcn->SetLineColor(4); signalFcn->SetLineWidth(1); // backFcn->Draw("same"); //signalFcn->Draw("same"); //Double_t Intg = abs(signalFcn->Integral(par[1]-factor*par[2],par[1]+factor*par[2])); ROOT::Math::GSLIntegrator ig(1.E-6,1.E-6,1000); ROOT::Math::WrappedTF1 wf(*fitter); ig.SetFunction(wf); double Intg = ig.Integral(par[1]-factor*par[2],par[1]+factor*par[2]); Double_t Intb = abs(backFcn->Integral(par[1]-factor*par[2],par[1]+factor*par[2])); Double_t binw = h33->GetBinWidth(1); Int_t yield = Intg/binw; Int_t bckgd = Intb/binw; //Double_t ratio = double(yield)/TMath::Sqrt(double(bckgd)); Double_t ratio = double(yield)/double(yield+bckgd); cout << yield << "\t" << ratio << endl; TAxis *x=h33->GetXaxis(); TAxis *y=h33->GetYaxis(); Double_t startx=x->GetXmin()+0.45*(x->GetXmax()-x->GetXmin()); /* Double_t starty0=0.5*h33->GetMaximum(); Double_t starty1=0.56*h33->GetMaximum(); Double_t starty2=0.62*h33->GetMaximum(); Double_t starty3=0.68*h33->GetMaximum(); Double_t starty4=0.74*h33->GetMaximum(); Double_t starty5=0.8*h33->GetMaximum(); */ Double_t starty0=0.35*h33->GetMaximum(); Double_t starty1=0.43*h33->GetMaximum(); Double_t starty2=0.49*h33->GetMaximum(); Double_t starty3=0.56*h33->GetMaximum(); Double_t starty4=0.63*h33->GetMaximum(); Double_t starty5=0.7*h33->GetMaximum(); double meanError = fitter->GetParError(1); double sigmaError = fitter->GetParError(2); if (draw_opt ==1) { TLatex *sum = new TLatex(startx*0.93, starty5,Form("Yield: %i",yield)); TLatex *sum12 = new TLatex(startx*0.93, starty4,Form("Background: %i",bckgd)); TLatex *sum0=new TLatex(startx*0.93, starty3,Form("Range: #pm %2.1f #sigma",factor)); TLatex *sum2=new TLatex(startx*0.93, starty2,Form("Mean: %4.4f #pm %.4f GeV",par[1], meanError)); TLatex *sum3=new TLatex(startx*0.93, starty1,Form("#sigma: %5.4f #pm %.4f GeV",par[2], sigmaError)); //TLatex *ra = new TLatex(startx*0.93, starty0,Form("#frac{S}{#sqrt{B}}= %.1f", ratio)); TLatex *ra = new TLatex(startx*0.93, starty0,Form("#frac{S}{S+B} = %1.4f", ratio)); sum->SetTextSize(0.04); sum->SetTextColor(kBlue);//2 sum->Draw("same"); sum12->SetTextSize(0.04); sum12->SetTextColor(kBlue);//6 sum12->Draw("same"); ra->SetTextSize(0.04); ra->SetTextColor(kBlue);//was black before; ra->Draw("same"); sum0->SetTextSize(0.04); sum0->SetTextColor(kBlue);//2 sum0->Draw("same"); sum2->SetTextSize(0.04); sum2->SetTextColor(kBlue);//4 sum2->Draw("same"); sum3->SetTextSize(0.04); sum3->SetTextColor(kBlue);//4 sum3->Draw("same"); } }
void functor_demo(){ cout<<endl<<"functor_demo :"<<endl; greater<int> ig; cout<<boolalpha<<ig(4,6)<<endl; cout<<greater<int>()(6,4)<<endl; }
void Gl1_NormPhys::go(const shared_ptr<IPhys>& ip, const shared_ptr<Interaction>& i, const shared_ptr<Body>& b1, const shared_ptr<Body>& b2, bool wireFrame){ if(!gluQuadric){ gluQuadric=gluNewQuadric(); if(!gluQuadric) throw runtime_error("Gl1_NormPhys::go unable to allocate new GLUquadric object (out of memory?)."); } NormPhys* np=static_cast<NormPhys*>(ip.get()); shared_ptr<IGeom> ig(i->geom); if(!ig) return; // changed meanwhile? GenericSpheresContact* geom=YADE_CAST<GenericSpheresContact*>(ig.get()); //if(!geom) cerr<<"Gl1_NormPhys: IGeom is not a GenericSpheresContact, but a "<<ig->getClassName()<<endl; Real fnNorm=np->normalForce.dot(geom->normal); if((signFilter>0 && fnNorm<0) || (signFilter<0 && fnNorm>0)) return; int fnSign=fnNorm>0?1:-1; fnNorm=abs(fnNorm); Real radiusScale=1.; // weak/strong fabric, only used if maxWeakFn is set if(!isnan(maxWeakFn)){ if(fnNorm*fnSign<maxWeakFn){ // weak fabric if(weakFilter>0) return; radiusScale=weakScale; } else { // strong fabric if(weakFilter<0) return; } } maxFn=max(fnNorm,maxFn); Real realMaxRadius; if(maxRadius<0){ if(geom->refR1>0) refRadius=min(geom->refR1,refRadius); if(geom->refR2>0) refRadius=min(geom->refR2,refRadius); realMaxRadius=refRadius; } else realMaxRadius=maxRadius; Real radius=radiusScale*realMaxRadius*(fnNorm/maxFn); // use logarithmic scale here? Vector3r color=Shop::scalarOnColorScale(fnNorm*fnSign,-maxFn,maxFn); # if 0 // get endpoints from body positions Vector3r p1=b1->state->pos, p2=b2->state->pos; Vector3r relPos; if(scene->isPeriodic){ relPos=p2+scene->cell->Hsize*i->cellDist.cast<Real>()-p1; p1=scene->cell->wrapShearedPt(p1); p2=p1+relPos; } else { relPos=p2-p1; } Real dist=relPos.norm(); #else // get endpoints from geom // max(r,0) handles r<0 which is the case for "radius" of the facet in Dem3DofGeom_FacetSphere Vector3r cp=scene->isPeriodic? scene->cell->wrapShearedPt(geom->contactPoint) : geom->contactPoint; Vector3r p1=cp-max(geom->refR1,(Real)0.)*geom->normal; Vector3r p2=cp+max(geom->refR2,(Real)0.)*geom->normal; const Vector3r& dispScale=scene->renderer ? scene->renderer->dispScale : Vector3r::Ones(); if(dispScale!=Vector3r::Ones()){ // move p1 and p2 by the same amounts as particles themselves would be moved p1+=dispScale.cwiseProduct(Vector3r(b1->state->pos-b1->state->refPos)); p2+=dispScale.cwiseProduct(Vector3r(b2->state->pos-b2->state->refPos)); } Vector3r relPos=p2-p1; Real dist=relPos.norm(); //max(geom->refR1,0.)+max(geom->refR2,0.); #endif glDisable(GL_CULL_FACE); glPushMatrix(); glTranslatef(p1[0],p1[1],p1[2]); Quaternionr q(Quaternionr().setFromTwoVectors(Vector3r(0,0,1),relPos/dist /* normalized */)); // using Transform with OpenGL: http://eigen.tuxfamily.org/dox/TutorialGeometry.html //glMultMatrixd(Eigen::Affine3d(q).data()); glMultMatrix(Eigen::Transform<Real,3,Eigen::Affine>(q).data()); glColor3v(color); gluCylinder(gluQuadric,radius,radius,dist,slices,stacks); glPopMatrix(); }
// ------------------------------------------------------------ // calculates the text in the tabular int TruthDiagram::calcDiagram() { Lines.clear(); Texts.clear(); Arcs.clear(); x1 = 0; // no scroll bar x3 = x2; // get size of text using the screen-compatible metric QFontMetrics metrics(QucsSettings.font, 0); int tHeight = metrics.lineSpacing(); QString Str; int colWidth=0, x=6, y; if(y2 < (41 + MIN_SCROLLBAR_SIZE)) y2 = 41 + MIN_SCROLLBAR_SIZE; if(y2 < (tHeight + 8)) y2 = tHeight + 8; y = y2 - tHeight - 6; // outer frame Lines.append(new Line(0, y2, x2, y2, QPen(Qt::black,0))); Lines.append(new Line(0, y2, 0, 0, QPen(Qt::black,0))); Lines.append(new Line(x2, y2, x2, 0, QPen(Qt::black,0))); Lines.append(new Line(0, 0, x2, 0, QPen(Qt::black,0))); Lines.append(new Line(0, y+2, x2, y+2, QPen(Qt::black,2))); if(xAxis.limit_min < 0.0) xAxis.limit_min = 0.0; Graph *firstGraph; QListIterator<Graph *> ig(Graphs); Graph *g = 0; if (ig.hasNext()) g= ig.next(); if(g == 0) { // no variables specified in diagram ? Str = QObject::tr("no variables"); colWidth = checkColumnWidth(Str, metrics, colWidth, x, y2); if(colWidth >= 0) Texts.append(new Text(x-4, y2-2, Str)); // independent variable return 0; } int NumAll=0; // how many numbers per column int NumLeft=0; // how many numbers could not be written char *py; int counting, invisibleCount=0; int startWriting, z; // any graph with data ? while(g->isEmpty()) { if (!ig.hasNext()) break; // no more graphs, exit loop g = ig.next(); // point to next graph } if(!g->isEmpty()) { // did we find a graph with data ? // ................................................ NumAll = g->axis(0)->count * g->countY; // number of values invisibleCount = NumAll - y/tHeight; if(invisibleCount <= 0) xAxis.limit_min = 0.0;// height bigger than needed else { if(invisibleCount < int(xAxis.limit_min + 0.5)) xAxis.limit_min = double(invisibleCount); // adjust limit of scroll bar NumLeft = invisibleCount - int(xAxis.limit_min + 0.5); } colWidth = 0; Texts.append(new Text(x-4, y2-2, Str)); // independent variable if(NumAll != 0) { z = metrics.width("1"); colWidth = metrics.width("0"); if(z > colWidth) colWidth = z; colWidth += 2; counting = int(log(double(NumAll)) / log(2.0) + 0.9999); // number of bits if((x+colWidth*counting) >= x2) { // enough space for text ? checkColumnWidth("0", metrics, 0, x2, y); goto funcEnd; } y = y2-tHeight-5; startWriting = x; for(z=int(xAxis.limit_min + 0.5); z<NumAll; z++) { if(y < tHeight) break; // no room for more rows ? startWriting = x; for(int zi=counting-1; zi>=0; zi--) { if(z & (1 << zi)) Str = "1"; else Str = "0"; Texts.append(new Text( startWriting, y, Str)); startWriting += colWidth; } y -= tHeight; } x = startWriting + 15; } Lines.append(new Line(x-8, y2, x-8, 0, QPen(Qt::black,2))); } // of "if no data in graphs" int zi, digitWidth; firstGraph = g; // ................................................ // all dependent variables foreach(Graph *g ,Graphs) { y = y2-tHeight-5; Str = g->Var; colWidth = checkColumnWidth(Str, metrics, 0, x, y2); if(colWidth < 0) goto funcEnd; Texts.append(new Text(x, y2-2, Str)); // dependent variable startWriting = int(xAxis.limit_min + 0.5); // when to reach visible area if(g->axis(0)) { if(sameDependencies(g, firstGraph)) { if(g->Var.right(2) != ".X") { // not a digital variable ? double *pdy = g->cPointsY - 2; for(z = NumAll; z>0; z--) { pdy += 2; if(startWriting-- > 0) continue; // reached visible area ? if(y < tHeight) break; // no room for more rows ? Str = QString::number(sqrt((*pdy)*(*pdy) + (*(pdy+1))*(*(pdy+1)))); colWidth = checkColumnWidth(Str, metrics, colWidth, x, y); if(colWidth < 0) goto funcEnd; Texts.append(new Text(x, y, Str)); y -= tHeight; } } else { // digital variable !!! py = (char*)g->cPointsY; counting = strlen((char*)py); // count number of "bits" digitWidth = metrics.width("X") + 2; if((x+digitWidth*counting) >= x2) { // enough space for "bit vector" ? checkColumnWidth("0", metrics, 0, x2, y); goto funcEnd; } for(z = NumAll; z>0; z--) { if(startWriting-- > 0) { // reached visible area ? py += counting + 1; continue; } if(y < tHeight) break; // no room for more rows ? zi = 0; while(*py) { Str = *(py++); Texts.append(new Text(x + zi, y, Str)); zi += digitWidth; } py++; y -= tHeight; } digitWidth *= counting; if(colWidth < digitWidth) colWidth = digitWidth; } } // of "if(sameDeps)" else { Str = QObject::tr("wrong dependency"); colWidth = checkColumnWidth(Str, metrics, colWidth, x, y); if(colWidth < 0) goto funcEnd; Texts.append(new Text(x, y, Str)); } } else { // no data in graph Str = QObject::tr("no data"); colWidth = checkColumnWidth(Str, metrics, colWidth, x, y); if(colWidth < 0) goto funcEnd; Texts.append(new Text(x, y, Str)); } x += colWidth+15; if(g != Graphs.last()) // do not paint last line Lines.append(new Line(x-8, y2, x-8, 0, QPen(Qt::black,0))); }
void genotype::read_vcf (string genofile, bool isgenoytpe) { igzstream ig (genofile.c_str()); string line; vector<snp> tmp; int j = 0 ; maxgpos = unordered_map<string, double> (); mingpos = unordered_map<string, double>(); maxppos = unordered_map<string, double> (); minppos = unordered_map<string, double>(); chrs = vector<string> (); double prevgpos ; double prevppos; string prevchr=""; int size = 10000; int inc = 10000; int linenum = 0 ; bool setind = false; int numhap = 2; if (isgenotype) numhap = 1; while (std::getline (ig, line) ) { linenum ++; char c = line[0]; if (c=='#') { if (line.find ("CHROM")!=string::npos) { if (!givenind) { vector<string> toks; functions::tokenize (line.c_str(), toks, " \t"); nind = toks.size() - 9 ; nind *= numhap; for (int i = 9 ; i < toks.size(); i++){ string id = toks[i]; indiv.push_back (ind(id,'U',"G")); if (!isgenotype) indiv.push_back (ind(id,'U',"G")); } setind = true; } } } else { vector<string> toks; functions::tokenize (line.c_str(), toks, " \t"); string id = toks[2]; string chr = toks[0]; double physpos = atof(toks[1].c_str()); double genpos = physpos*1.3/1e8; if (id.compare (".")==0) { id = chr+":"+toks[1]; } string ref = toks[3]; string var = toks[4]; string pass = toks[6]; string desc = toks[7]; string format = toks[8]; if (pass.compare("PASS")!=0) continue; if (ref.compare (".")==0) continue; if (desc.compare (".") == 0 ) { cout << "Warning: No INFO field found. Assuming site is a SNP " << endl; } vector<string> tok1; functions::tokenize (desc.c_str(), tok1, ";"); if (tok1[0].compare("SNP")!=0) continue; // Fill the snps if (chr.compare(prevchr)==0) { if (physpos >= prevppos){ prevgpos = genpos; prevppos = physpos; } else { cerr << "Invalid snps in " << genofile <<" : Line " << linenum << "\t Must have non-decreasing physical positions" << endl; // exit (1); } } else { prevchr = chr; prevgpos = genpos; prevppos = physpos; if (snps.find(chr) != snps.end ()) { cerr << "Invalid snps in "<< genofile << " : Line " << linenum << "\t SNPs on a chromosome must be consecutive" << endl; exit (1); } chrs.push_back(chr); snps[chr] = vector<snp>(); // snps[chr].reserve (size); } /* if (j==size){ size += inc; snps[chr].reserve(size); } */ if ( maxppos.find(chr) == maxppos.end()) { maxppos[chr] = physpos; } else if (physpos > maxppos[chr]) maxppos[chr] = physpos; if ( minppos.find(chr) == minppos.end()) { minppos[chr] = physpos; } else if (physpos < minppos[chr]) minppos[chr] = physpos; if ( maxgpos.find(chr) == maxgpos.end()) { maxgpos[chr] = genpos; } else if (genpos > maxgpos[chr]) maxgpos[chr] = genpos; if ( mingpos.find(chr) == mingpos.end()) { mingpos[chr] = genpos; } else if (genpos < mingpos[chr]) mingpos[chr] = genpos; // Fill in the genotypes tok1.resize (0); functions::tokenize (format.c_str(), tok1,":"); int gind = -1; for (int i = 0 ; i < tok1.size(); i++){ if (tok1[i].compare ("GT")==0) { gind = i; break; } } if (gind == -1) continue; snps[chr].push_back (snp(id,chr,physpos,genpos,var,ref)); vector<int> >ype = snps[chr].back().gtype; j++; if (setind) { if (nind != numhap*(toks.size()-9)){ cerr << "Bad genotype in " << genofile << ": Line "<< linenum << endl; exit(1); } } else { nind = toks.size() - 9; nind *= numhap; setind = true; } gtype.resize(nind, 9); for (int i = 9, k = 0; i < toks.size(); i++, k++){ tok1.resize(0); functions::tokenize(toks[i], tok1,","); if (isgenotype) { int a1 = tok1[gind][0]; int a2 = tok1[gind][2]; gtype[k] = (a1-48) + (a2-48); } else { int a1 = tok1[gind][0]; int a2 = tok1[gind][2]; gtype[2*k] = a1-48; gtype[2*k+1] = a2-48; } } } if (j%10000==0) { io::println ("Read " + tostring (j) + " lines" ,0); } } nchr = chrs.size (); nsnps = j; if (io::debug >= 2 ) { cout << "genotype = " << to_string (); } ig.close (); }
void learn(attributes_iterator_type attributes_from, attributes_iterator_type attributes_to, size_t attribute_dimension, classifications_iterator_type classifications_from) { size_t sample_size = attributes_to-attributes_from; classifications_iterator_type classifications_to = classifications_from + sample_size; // check for termination { size_t n_y0 = std::count(classifications_from,classifications_to,0); size_t n_y1 = sample_size - n_y0; if (n_y0 > ((double)sample_size)*termination_ratio || n_y1 > ((double)sample_size)*termination_ratio || sample_size < minimum_sample) { is_end_node = true; end_node_decision = n_y1 > n_y0; return; } } // decision the best decision { std::vector<std::pair<size_t,double> > decision_list; for (size_t index = 0;index < attribute_dimension;++index) { std::pair<attribute_type,attribute_type> range = get_value_range(attributes_from,attributes_to,index); double step = (range.first-range.second)/5.0; for (double value = range.second+step;value <= range.first-step;value += step) decision_list.push_back(std::make_pair(index,value)); } std::vector<double> ig(decision_list.size()); for (size_t index = 0;index < decision_list.size();++index) { attribute_index = decision_list[index].first; param = decision_list[index].second; ig[index] = information_gain(attributes_from,attributes_to,classifications_from); } size_t best_decision_index = std::max_element(ig.begin(),ig.end())-ig.begin(); attribute_index = decision_list[best_decision_index].first; param = decision_list[best_decision_index].second; } // split tree { std::vector<std::vector<attribute_type> > right_attributes; std::vector<std::vector<attribute_type> > left_attributes; std::vector<classification_type> right_classification; std::vector<classification_type> left_classification; right_attributes.reserve(sample_size); left_attributes.reserve(sample_size); right_classification.reserve(sample_size); left_classification.reserve(sample_size); for (size_t index = 0;index < sample_size;++index) if (attributes_from[index][attribute_index] > param) { right_attributes.push_back( std::vector<attribute_type>( &(attributes_from[index][0]),&(attributes_from[index][0])+attribute_dimension)); right_classification.push_back(classifications_from[index]); } else { left_attributes.push_back( std::vector<attribute_type>( &(attributes_from[index][0]),&(attributes_from[index][0])+attribute_dimension)); left_classification.push_back(classifications_from[index]); } right_tree.reset(new decision_tree(minimum_sample,termination_ratio)); left_tree.reset(new decision_tree(minimum_sample,termination_ratio)); right_tree->learn(right_attributes.begin(),right_attributes.end(),attribute_dimension,right_classification.begin()); left_tree->learn(left_attributes.begin(),left_attributes.end(),attribute_dimension,left_classification.begin()); is_end_node = false; } }