int main() { try { std::cout << Divide(5, 2) << std::endl; std::cout << Divide(10, 0) << std::endl; std::cout << Divide(3, 3) << std::endl; } catch (const std::invalid_argument& e) { std::cout << "Caught exception: " << e.what() << std::endl; } return 0; }
void VirtualSpace_Release(uint32_t* logAddrToRealease, uint32_t nbPages) { FreeSpace* nextFS = VirtualSpace_GetNextFreeSpace(logAddrToRealease); FreeSpace* prevFS = VirtualSpace_GetPrevious(nextFS); uint8_t createNewFS = 1; if((*nextFS).addrSpace==logAddrToRealease+nbPages*PAGE_SIZE) { (*nextFS).addrSpace = logAddrToRealease; (*nextFS).nbPagesFree += nbPages; createNewFS = 0; } if((*prevFS).addrSpace+(*prevFS).nbPagesFree*PAGE_SIZE==logAddrToRealease) { (*prevFS).nbPagesFree += nbPages; createNewFS = 0; } if(createNewFS) { uint32_t nbMiniFrames; uint32_t mod; Divide( sizeof(FreeSpace), MINI_FRAMES_SIZE_OF_A_FRAME+1, &nbMiniFrames,&mod); FreeSpace* newFS = (FreeSpace*)Mini_Alloc(nbMiniFrames,0); (*newFS).nbPagesFree = nbPages; (*newFS).addrSpace = logAddrToRealease; (*newFS).ptNextFreeSpace = nextFS; (*prevFS).ptNextFreeSpace = newFS; } }
// Creates a sphere Mesh* CreateSphere(int subdivisions) { nextIndex = 0; // TODO: calc how many items in the arrays we need vertices = new Vertex[100000]; vertexCurrentIndex = 0; indices = new USHORT[100000]; indexCurrentIndex = 0; AddBaseTriangle(CreateVector(0, 0, 1), CreateVector(1, 0, 0), CreateVector(0, 1, 0)); AddBaseTriangle(CreateVector(1, 0, 0), CreateVector(0, 0, -1), CreateVector(0, 1, 0)); AddBaseTriangle(CreateVector(0, 0, -1), CreateVector(-1, 0, 0), CreateVector(0, 1, 0)); AddBaseTriangle(CreateVector(-1, 0, 0), CreateVector(0, 0, 1), CreateVector(0, 1, 0)); AddBaseTriangle(CreateVector(1, 0, 0), CreateVector(0, 0, 1), CreateVector(0, -1, 0)); AddBaseTriangle(CreateVector(0, 0, -1), CreateVector(1, 0, 0), CreateVector(0, -1, 0)); AddBaseTriangle(CreateVector(-1, 0, 0), CreateVector(0, 0, -1), CreateVector(0, -1, 0)); AddBaseTriangle(CreateVector(0, 0, 1), CreateVector(-1, 0, 0), CreateVector(0, -1, 0)); for (int division = 1; division < subdivisions; division++) Divide(); Mesh* mesh = new Mesh(); mesh->Set(vertices, vertexCurrentIndex, indices, indexCurrentIndex); // Free allocated arrays delete [] vertices; delete [] indices; return mesh; }
int main() { int x; int start=0,end=100; int y=(start+end)/2; printf("*****************************************************************\n"); printf("Enter the number corresponding to the desired pay rate or action:\n"); printf("a) add\t\t\ts) subtract\n"); printf("m) multiply\t\td) divide\n"); printf("q) quit\n"); printf("*****************************************************************\n"); x=getchar(); switch(x) { case 'a': Add(); break; case 's': Subtract(); break; case 'm': Mutliply(); break; case 'd': Divide(); break; case 'q': printf("Bye~~~~~~\n"); break; } }
void efficiencyBinomialErrors() { printf("\n Get the binomial errors for efficiencies\n\n"); auto h_num = new TH1D("h_num", "h_num", nbins, 0, nbins); auto h_den = new TH1D("h_den", "h_den", nbins, 0, nbins); for (int i=0; i<nbins; i++) { h_num->SetBinContent(i+1, n_num[i]); h_den->SetBinContent(i+1, n_den[i]); } auto graph = new TGraphAsymmErrors(); graph->Divide(h_num, h_den, "cl=0.683 b(1,1) mode"); auto canvas = new TCanvas("canvas", "canvas"); graph->SetMarkerStyle(kFullCircle); graph->Draw("apz"); graph->Print(); }
void M2MFstAligner::expectation( ){ /* Here we compute the arc posteriors. This routine is almost fun to implement in the FST paradigm. */ for( unsigned int i=0; i<fsas.size(); i++ ){ //Compute Forward and Backward probabilities ShortestDistance( fsas.at(i), &alpha ); ShortestDistance( fsas.at(i), &beta, true ); //Compute the normalized Gamma probabilities and // update our running tally for( StateIterator<VectorFst<LogArc> > siter(fsas.at(i)); !siter.Done(); siter.Next() ){ LogArc::StateId q = siter.Value(); for( ArcIterator<VectorFst<LogArc> > aiter(fsas.at(i),q); !aiter.Done(); aiter.Next() ){ const LogArc& arc = aiter.Value(); const LogWeight& gamma = Divide(Times(Times(alpha[q], arc.weight), beta[arc.nextstate]), beta[0]); //Check for any BadValue results, otherwise add to the tally. //We call this 'prev_alignment_model' which may seem misleading, but // this conventions leads to 'alignment_model' being the final version. if( gamma.Value()==gamma.Value() ){ prev_alignment_model[arc.ilabel] = Plus(prev_alignment_model[arc.ilabel], gamma); total = Plus(total, gamma); } } } alpha.clear(); beta.clear(); } }
float M2MFstAligner::maximization(bool lastiter) { //Maximization. Simple count normalization. Probably get an improvement // by using a more sophisticated regularization approach. map<LogArc::Label,LogWeight>::iterator it; float change = abs(total.Value() - prevTotal.Value()); //cout << "Total: " << total << " Change: " << abs(total.Value()-prevTotal.Value()) << endl; prevTotal = total; //Normalize and iterate to the next model. We apply it dynamically // during the expectation step. for (it = prev_alignment_model.begin(); it != prev_alignment_model.end(); it++) { alignment_model[(*it).first] = Divide((*it).second, total); (*it).second = LogWeight::Zero(); } for (int i = 0; i < fsas.size(); i++) { for (StateIterator<VectorFst<LogArc> > siter(fsas[i]); !siter.Done(); siter.Next()) { LogArc::StateId q = siter.Value(); for (MutableArcIterator<VectorFst<LogArc> > aiter(&fsas[i], q); !aiter.Done(); aiter.Next()) { LogArc arc = aiter.Value(); arc.weight = alignment_model[arc.ilabel]; aiter.SetValue(arc); } } } total = LogWeight::Zero(); return change; }
/// <summary> /// Overloaded operator (/) for solving the following equation: result = value1 / value2 /// </summary> /// <param name="src">Large Integer value wich represet value2</param> /// <returns>Result of operation</returns> CLargeInteger CLargeInteger::operator / (const CLargeInteger &src) { CLargeInteger res; Divide( this, &src, &res); return res; }
void solve() { scanf("%d", &n); for (int i = 0; i < n; i++) scanf("%lf%lf", &p[i].x, &p[i].y), p[i].index = i, p[i].in = NULL; Alloc_memory(); sort(p, p + n); for (int i = 0; i < n; i++) Q[i] = p + i; edge *L, *R; Divide(0, n - 1, &L, &R); M = 0; Make_Graph(); Kruskal(); }
// Solution taken from: http://mathworld.wolfram.com/QuarticEquation.html // and http://www.csit.fsu.edu/~burkardt/f_src/subpak/subpak.f90 int Factor(double a4,double a3,double a2,double a1,double a0,double roots[4][2],const double& EPS){ double R[2],D[2],E[2],R2[2]; if(fabs(a4)<EPS){return Factor(a3,a2,a1,a0,roots,EPS);} a3/=a4; a2/=a4; a1/=a4; a0/=a4; Factor(1.0,-a2,a3*a1-4.0*a0,-a3*a3*a0+4.0*a2*a0-a1*a1,roots,EPS); R2[0]=a3*a3/4.0-a2+roots[0][0]; R2[1]=0; Sqrt(R2,R); if(fabs(R[0])>10e-8){ double temp1[2],temp2[2]; double p1[2],p2[2]; p1[0]=a3*a3*0.75-2.0*a2-R2[0]; p1[1]=0; temp2[0]=((4.0*a3*a2-8.0*a1-a3*a3*a3)/4.0); temp2[1]=0; Divide(temp2,R,p2); Add (p1,p2,temp1); Subtract(p1,p2,temp2); Sqrt(temp1,D); Sqrt(temp2,E); } else{ R[0]=R[1]=0; double temp1[2],temp2[2]; temp1[0]=roots[0][0]*roots[0][0]-4.0*a0; temp1[1]=0; Sqrt(temp1,temp2); temp1[0]=a3*a3*0.75-2.0*a2+2.0*temp2[0]; temp1[1]= 2.0*temp2[1]; Sqrt(temp1,D); temp1[0]=a3*a3*0.75-2.0*a2-2.0*temp2[0]; temp1[1]= -2.0*temp2[1]; Sqrt(temp1,E); } roots[0][0]=-a3/4.0+R[0]/2.0+D[0]/2.0; roots[0][1]= R[1]/2.0+D[1]/2.0; roots[1][0]=-a3/4.0+R[0]/2.0-D[0]/2.0; roots[1][1]= R[1]/2.0-D[1]/2.0; roots[2][0]=-a3/4.0-R[0]/2.0+E[0]/2.0; roots[2][1]= -R[1]/2.0+E[1]/2.0; roots[3][0]=-a3/4.0-R[0]/2.0-E[0]/2.0; roots[3][1]= -R[1]/2.0-E[1]/2.0; return 4; }
void Term() { SignedFactor(); while(Look == '*' || Look == '/') { EmitLn("push rax"); switch(Look) { case '*' : Multiply();break; case '/' : Divide();break; } } }
int main() { LinkList l,la,lb,lc; l=CreateList(7); la=CreateList2(0); lb=CreateList2(0); lc=CreateList2(0); Output(l); Divide(l,la,lb,lc); return 0; }
/// <summary> /// Overloaded operator (/=) for solving the following equation: value1 /= value2 /// </summary> /// <param name="src">Large Integer value wich represet value2</param> /// <returns>Return in the value1 result of operation</returns> CLargeInteger CLargeInteger::operator /= (const CLargeInteger &src) { CLargeInteger tmp(*this); Init(); Divide( &tmp, &src, this); return *this; }
void QuickMedium(T* &vector, int ini, int fin){ if (fin-ini == 1){ if (vector[ini]>vector[fin]) Swap(vector[ini], vector[fin]); } else if (fin-ini > 1){ int division = Divide(vector, ini, fin); SlowMedium(vector, ini, division-1); SlowMedium(vector, division+1, fin); } }
// Divide this surface into two surfaces in // S direction if bS is true, u = (m_fS[0]+m_fS[1])/2 // T direction if bS is false, u = (m_fT[0]+m_fT[1])/2 bool MH_SrfBezier::DivideHalf(bool bS, MH_SrfBezier& bezier1, MH_SrfBezier& bezier2) const { float u; if(bS) u = (m_fS[0]+m_fS[1])/2.0f; else u = (m_fT[0]+m_fT[1])/2.0f; return Divide(bS, u, bezier1, bezier2); }
Maze :: Maze() { numRows = 21; numCols = 32; grid = new char*[numRows]; for(int i = 0; i < numRows; i++) grid[i] = new char[numCols]; /* strcpy (grid[0], "###############################"); strcpy (grid[1], "#O# # # # #"); strcpy (grid[2], "# # ### ##### # ##### ### # ###"); strcpy (grid[3], "# # # # # # # # #"); strcpy (grid[4], "# # # # # # ### ### ### # ### #"); strcpy (grid[5], "# # # # # # # # # #"); strcpy (grid[6], "# # # ### ### ####### ##### # #"); strcpy (grid[7], "# # # # # # # # #"); strcpy (grid[8], "########### # # ######### # ###"); strcpy (grid[9], "# # # # # #"); strcpy(grid[10], "# # # ####### # # # # # ##### #"); strcpy(grid[11], "# # # # # # # # # # #"); strcpy(grid[12], "### ### # # ##### ### # #######"); strcpy(grid[13], "# # # # # # # # # #"); strcpy(grid[14], "# # # # # # ############# # # #"); strcpy(grid[15], "# # # # # # # #"); strcpy(grid[16], "# # ##### ##### ####### # #####"); strcpy(grid[17], "# # # # # # # #"); strcpy(grid[18], "# ####### # ### # ### ##### # #"); strcpy(grid[19], "# # # # #X#"); strcpy(grid[20], "###############################"); */ for(int g = 0; g < 21; g++) { grid[g][0] = '#'; grid[g][30] = '#'; } for(int h = 0; h < 31; h++) { grid[0][h] = '#'; grid[20][h] = '#'; } for(int m = 1; m < 20; m++) for(int n = 1; n < 30; n++) grid[m][n] = ' '; srand(time(NULL)); Divide(0, 20, 0, 30); endRow = 19; endCol = 29; currentRow = 1; currentCol = 1; grid[1][1] = 'O'; grid[19][29] = 'X'; }
void macro6(){ auto sig_h=new TH1F("sig_h","Signal Histo",50,0,10); auto gaus_h1=new TH1F("gaus_h1","Gauss Histo 1",30,0,10); auto gaus_h2=new TH1F("gaus_h2","Gauss Histo 2",30,0,10); auto bkg_h=new TH1F("exp_h","Exponential Histo",50,0,10); // simulate the measurements TRandom3 rndgen; for (int imeas=0;imeas<4000;imeas++){ bkg_h->Fill(rndgen.Exp(4)); if (imeas%4==0) gaus_h1->Fill(rndgen.Gaus(5,2)); if (imeas%4==0) gaus_h2->Fill(rndgen.Gaus(5,2)); if (imeas%10==0)sig_h->Fill(rndgen.Gaus(5,.5));} // Format Histograms int i=0; for (auto hist : {sig_h,bkg_h,gaus_h1,gaus_h2}) format_h(hist,1+i++); // Sum auto sum_h= new TH1F(*bkg_h); sum_h->Add(sig_h,1.); sum_h->SetTitle("Exponential + Gaussian;X variable;Y variable"); format_h(sum_h,kBlue); auto c_sum= new TCanvas(); sum_h->Draw("hist"); bkg_h->Draw("SameHist"); sig_h->Draw("SameHist"); // Divide auto dividend=new TH1F(*gaus_h1); dividend->Divide(gaus_h2); // Graphical Maquillage dividend->SetTitle(";X axis;Gaus Histo 1 / Gaus Histo 2"); format_h(dividend,kOrange); gaus_h1->SetTitle(";;Gaus Histo 1 and Gaus Histo 2"); gStyle->SetOptStat(0); TCanvas* c_divide= new TCanvas(); c_divide->Divide(1,2,0,0); c_divide->cd(1); c_divide->GetPad(1)->SetRightMargin(.01); gaus_h1->DrawNormalized("Hist"); gaus_h2->DrawNormalized("HistSame"); c_divide->cd(2); dividend->GetYaxis()->SetRangeUser(0,2.49); c_divide->GetPad(2)->SetGridy(); c_divide->GetPad(2)->SetRightMargin(.01); dividend->Draw(); }
void Divide(int s, int t, edge **L, edge **R) { edge *a, *b, *c, *ll, *lr, *rl, *rr, *tangent; int n = t - s + 1; if (n == 2) *L = *R = Make_edge(Q[s], Q[t]); else if (n == 3) { a = Make_edge(Q[s], Q[s + 1]), b = Make_edge(Q[s + 1], Q[t]); Splice(a, b, Q[s + 1]); double v = C3(Q[s], Q[s + 1], Q[t]); if (v > eps) c = Join(a, Q[s], b, Q[t], 0), *L = a, *R = b; else if (v < -eps) c = Join(a, Q[s], b, Q[t], 1), *L = c, *R = c; else *L = a, *R = b; } else if (n > 3) { int split = (s + t) / 2; Divide(s, split, &ll, &lr); Divide(split + 1, t, &rl, &rr); Merge(lr, Q[split], rl, Q[split + 1], &tangent); if (Oi(tangent) == Q[s]) ll = tangent; if (Dt(tangent) == Q[t]) rr = tangent; *L = ll; *R = rr; } }
void Term1() { NewLine(); while(Look == '*' || Look == '/') { Push(); switch(Look) { case '*': Multiply(); break; case '/': Divide(); break; } NewLine(); } }
int LimitedKnapsack(std::vector<int> c, std::vector<int> w, int B, std::vector<int> n){ std::vector<int> new_c, new_w; for (int i = 0; i < n.size(); ++i) { std::vector<int> d = Divide(n[i]); for(auto l : d){ new_c.push_back(l*c[i]); new_w.push_back(l*w[i]); } } return knapsack(new_c,new_w,B); }
void vMem_Init(FreeSpace* pt_firstFSDescriptor) { uint32_t nbPagesFree; uint32_t mod; Divide( (HEAP_END-HEAP_BEG), PAGE_SIZE, &nbPagesFree,&mod); (*pt_firstFSDescriptor).nbPagesFree = nbPagesFree; (*pt_firstFSDescriptor).addrSpace = (uint32_t*)HEAP_BEG; (*pt_firstFSDescriptor).ptNextFreeSpace = pt_firstFSDescriptor; }
//4. (Define) Function int main (int argc, char *argv[]){ ULong firstNumber; ULong secondNumber; ULong quotient; ULong remainder; Input(&firstNumber, &secondNumber); Divide(firstNumber, secondNumber, "ient, &remainder); Output(quotient, remainder); return 0; }
float M2MFstAligner::maximization( bool lastiter ){ //Maximization. Standard approach is simple count normalization. //The 'penalize' option penalizes links by total length. Results seem to be inconclusive. // Probably get an improvement by distinguishing between gaps and insertions, etc. bool cond = false; float change = abs(total.Value()-prevTotal.Value()); if( cond==false ){ map<LogArc::Label,LogWeight>::iterator it; //cout << "Total: " << total << " Change: " << abs(total.Value()-prevTotal.Value()) << endl; prevTotal = total; //Normalize and iterate to the next model. We apply it dynamically // during the expectation step. for( it=prev_alignment_model.begin(); it != prev_alignment_model.end(); it++ ){ alignment_model[(*it).first] = Divide((*it).second,total); (*it).second = LogWeight::Zero(); } }else{ _conditional_max( true ); } for( unsigned int i=0; i<fsas.size(); i++ ){ for( StateIterator<VectorFst<LogArc> > siter(fsas[i]); !siter.Done(); siter.Next() ){ LogArc::StateId q = siter.Value(); for( MutableArcIterator<VectorFst<LogArc> > aiter(&fsas[i], q); !aiter.Done(); aiter.Next() ){ LogArc arc = aiter.Value(); if( penalize_em==true ){ LabelDatum* ld = &penalties[arc.ilabel]; if( ld->lhs>1 && ld->rhs>1 ){ arc.weight = 99; }else if( ld->lhsE==false && ld->rhsE==false ){ arc.weight = arc.weight.Value() * ld->tot; } /* else{ arc.weight = arc.weight.Value() * (ld->tot+10); } */ if( arc.weight == LogWeight::Zero() || arc.weight != arc.weight ) arc.weight = 99; }else{ arc.weight = alignment_model[arc.ilabel]; } aiter.SetValue(arc); } } } total = LogWeight::Zero(); return change; }
void Term (){ Factor(); EmitLn("MOVE D0,-(SP)"); while (Look[0] == '*' || Look[0] == '/'){ switch (Look[0]){ case '*': Multiply(); break; case '/': Divide(); break; default: Expected("Mulop"); } } }
void pk (int v[], int p, int inf, int sup, int k){ int pivote, pivote_sup, pivote_inf; int li=0; int ls=LVECT-1; while(p>=0){ pivote=Divide(v, li, ls); if((inf<=pivote)&&(pivote<=sup) && (k!= pivote)){ /*Caso 1: Dentro del rango*/ if(pivote==inf) li=pivote+1; else if(pivote==sup) ls=pivote-1; else{ pivote_inf=Divide(v, li, pivote-1); /*Búsqueda por abajo*/ pivote_sup=Divide(v, pivote+1, ls); /*Búsqueda por arriba*/ if(inf>pivote_inf) li=pivote_inf; if(sup<pivote_sup) ls=pivote_sup; } p--; } if(pivote>sup){/*Caso 2: Fuera del rango, por arriba*/ ls=pivote-1; } if(pivote<inf){/*Caso 3: Fuera del rango, por abajo*/ li=pivote+1; } } }
void VQ_target_vec_norm(Ipp16s gain, Ipp16s nlsgain, Ipp16s* target, Ipp16s* nlstarget){ Ipp16s tmp, nlstmp, nls; Ipp32s k, aa0; Divide(16384, 14, gain, nlsgain, &tmp, &nlstmp); for(k=0; k<IDIM; k++) { aa0 = tmp * target[k]; target[k] = ShiftR_32s(aa0, 15); } *nlstarget = 2 + (nlstmp - 15); Vscale_16s(target,IDIM, IDIM, 14, target, &nls); *nlstarget = (*nlstarget) + nls; return; }
int InsereInterno(struct No *N, Chave chave, int p, int *itemPromovido, struct No **filhoDItemPromovido, int * valorAssociadoPromovido, int *x) { //Se for um nó nulo, insere na página pai if(N == NULL) { *itemPromovido = chave; *valorAssociadoPromovido = p; *filhoDItemPromovido = NULL; *x = 1; return PROMOVE; } //Senão, procura o ponto i onde "chave" deveria estar na página atual int i; for(i = 0; i < N->numElementos && chave > N->valoresAssociados[i]; i++); //Se a chave já estiver na página, retorna if(i < N->numElementos && chave == N->valoresAssociados[i] ) { printf("ERRO, item ja existente\n"); return CHAVE_JA_EXISTE; } //Senão, manda inserir na página filha adequada int retorno = InsereInterno(N->Filho[i], chave, p, itemPromovido, filhoDItemPromovido, valorAssociadoPromovido, x); //Se nenhum item for promovido da página filha, retorna if(retorno == NAO_PROMOVE || retorno == CHAVE_JA_EXISTE) return retorno; //Se um item for promovido e houver espaço nesta página if(N->numElementos < ORDEM-1) { int pos = i; for(i = N->numElementos; i > pos; i--) { N->chaves[i] = N->chaves[i-1]; N->valoresAssociados[i] = N->valoresAssociados[i-1]; N->Filho[i+1] = N->Filho[i]; } N->valoresAssociados[pos] = *valorAssociadoPromovido; N->Filho[pos+1] = *filhoDItemPromovido; N->chaves[pos] = *itemPromovido; N->numElementos++; return NAO_PROMOVE; } //Se não houver espaço, faz a divisão de página //itemPromovido será o pivô e filhoDItemPromovido será a nova página, o pivô será inserido na página pai Divide(N, itemPromovido, filhoDItemPromovido, valorAssociadoPromovido); return PROMOVE; }
LispObject* PowerFloat(LispObject* int1, LispObject* int2, LispEnvironment& aEnvironment,int aPrecision) { if (int2->Number(aPrecision)->iNumber->iExp != 0) throw LispErrNotInteger(); // Raising to the power of an integer can be done fastest by squaring // and bitshifting: x^(a+b) = x^a*x^b . Then, regarding each bit // in y (seen as a binary number) as added, the algorithm becomes: // ANumber x(*int1->Number(aPrecision)->iNumber); ANumber y(*int2->Number(aPrecision)->iNumber); bool neg = y.iNegative; y.iNegative=false; // result <- 1 ANumber result("1",aPrecision); // base <- x ANumber base(aPrecision); base.CopyFrom(x); ANumber copy(aPrecision); // while (y!=0) while (!y.IsZero()) { // if (y&1 != 0) if ( (y[0] & 1) != 0) { // result <- result*base copy.CopyFrom(result); Multiply(result,copy,base); } // base <- base*base copy.CopyFrom(base); Multiply(base,copy,copy); // y <- y>>1 BaseShiftRight(y,1); } if (neg) { ANumber one("1",aPrecision); ANumber dummy(10); copy.CopyFrom(result); Divide(result,dummy,one,copy); } // result return FloatToString(result, aEnvironment); }
// Create, Draw and fit a TGraph2DErrors void macro4(){ gStyle->SetPalette(57); const double e = 0.3; const int nd = 500; TRandom3 my_random_generator; TF2 f2("f2", "1000*(([0]*sin(x)/x)*([1]*sin(y)/y))+200", -6,6,-6,6); f2.SetParameters(1,1); TGraph2DErrors dte(nd); // Fill the 2D graph double rnd, x, y, z, ex, ey, ez; for (Int_t i=0; i<nd; i++) { f2.GetRandom2(x,y); // A random number in [-e,e] rnd = my_random_generator.Uniform(-e,e); z = f2.Eval(x,y)*(1+rnd); dte.SetPoint(i,x,y,z); ex = 0.05*my_random_generator.Uniform(); ey = 0.05*my_random_generator.Uniform(); ez = fabs(z*rnd); dte.SetPointError(i,ex,ey,ez); } // Fit function to generated data f2.SetParameters(0.7,1.5); // set initial values for fit f2.SetTitle("Fitted 2D function"); dte.Fit(&f2); // Plot the result auto c1 = new TCanvas(); f2.SetLineWidth(1); f2.SetLineColor(kBlue-5); TF2 *f2c = (TF2*)f2.DrawClone("Surf1"); TAxis *Xaxis = f2c->GetXaxis(); TAxis *Yaxis = f2c->GetYaxis(); TAxis *Zaxis = f2c->GetZaxis(); Xaxis->SetTitle("X Title"); Xaxis->SetTitleOffset(1.5); Yaxis->SetTitle("Y Title"); Yaxis->SetTitleOffset(1.5); Zaxis->SetTitle("Z Title"); Zaxis->SetTitleOffset(1.5); dte.DrawClone("P0 Same"); // Make the x and y projections auto c_p= new TCanvas("ProjCan", "The Projections",1000,400); c_p->Divide(2,1); c_p->cd(1); dte.Project("x")->Draw(); c_p->cd(2); dte.Project("y")->Draw(); }
void pk (int v[], int p, int inf, int sup, int k){ /*algoritmo p-k*/ int pivote, li, ls, low, up; int i=0; li=0; ls=LVECT-1; low=k-inf; up=sup-k; pivote=Divide(v, li, ls); while(res[sup-inf-1]<0){ if((inf<=pivote)&&(pivote<=sup) ){ res[i]=v[pivote]; i++; pivote=Divide(v, li, pivote-1); pivote=Divide(v, pivote+1, ls); } if(pivote>=sup){ ls=pivote -1; pivote=Divide(v, li, ls); } if(pivote<=inf){ li=pivote +1; pivote=Divide(v, li, ls); } } printf("\n===RESULTADO===\n"); printvec(res, sup-inf); printf("\n"); }