int main(void) { printf("Nullstelle [2, 4], eps=10^-8: %f\n", bisection(2, 4, 10e-8)); printf("Nullstelle [4, 6], eps=10^-2: %f\n", bisection(4, 6, 10e-2)); printf("Nullstelle [6, 8], eps=10^-8: %f\n", bisection(6, 8, 10e-8)); return 0; }
double bisection (double xl, double xr, double tolerance, double func()) { double d = (xl + xr) / 2, f = (*func)(d); if (fabs(f) <= tolerance) return d; if (sign(f) == sign((*func)(xl))) return bisection(d, xr, tolerance, func); return bisection(xl, d, tolerance, func); }
Stokhos::KL::OneDExponentialCovarianceFunction<value_type>:: OneDExponentialCovarianceFunction(int M, const value_type& a, const value_type& b, const value_type& L_, const std::string& dim_name, Teuchos::ParameterList& solverParams) : L(L_), eig_pair(M) { // Get parameters with default values magnitude_type eps = solverParams.get("Bound Perturbation Size", 1e-6); magnitude_type tol = solverParams.get("Nonlinear Solver Tolerance", 1e-10); int max_it = solverParams.get("Maximum Nonlinear Solver Iterations", 100); value_type aa, alpha, omega, lambda; int i=0; double pi = 4.0*std::atan(1.0); int idx = 0; aa = (b-a)/2.0; while (i < M-1) { alpha = aa/L; omega = bisection(EigFuncCos(alpha), idx*pi, idx*pi+pi/2.0-eps, tol, max_it) / aa; lambda = 2.0*L/(L*L*omega*omega + 1.0); eig_pair[i].eig_val = lambda; eig_pair[i].eig_func = Teuchos::rcp(new ExponentialOneDEigenFunction<value_type>( ExponentialOneDEigenFunction<value_type>::COS, a, b, omega, dim_name) ); i++; omega = bisection(EigFuncSin(alpha), idx*pi+pi/2.0+eps, (idx+1)*pi, tol, max_it) / aa; lambda = 2.0*L/(L*L*omega*omega + 1.0); eig_pair[i].eig_val = lambda; eig_pair[i].eig_func = Teuchos::rcp(new ExponentialOneDEigenFunction<value_type>( ExponentialOneDEigenFunction<value_type>::SIN, a, b, omega, dim_name) ); i++; idx++; } if (i < M) { omega = bisection(EigFuncCos(alpha), idx*pi, idx*pi+pi/2.0-eps, tol, max_it) / aa; lambda = 2.0*L/(L*L*omega*omega + 1.0); eig_pair[i].eig_val = lambda; eig_pair[i].eig_func = Teuchos::rcp(new ExponentialOneDEigenFunction<value_type>( ExponentialOneDEigenFunction<value_type>::COS, a, b, omega, dim_name) ); } }
int main() { double xl = -100.0, xr = 100.0, t = 0.0000001; puts("\nTest 1: x^3 = 0."); printf("xl = %f; xr = %f; tolerance = %f\n", -100.0, 150.0, t); printf("Bisection: x = %f\n", bisection(-100.0, 150.0, t, &cube)); printf("xl = %f; xr = %f; tolerance = %f\n", -0.001, 0.001, t); printf("Secant: x = %f\n", secant(-0.001, 0.001, t, &cube)); puts("\nTest 2: Matrix test (x^j = 10^i)."); for(j = 1; j < 10; j++) for(i = 1; i < 10; i++) { printf("j = %f; i = %f\n", j, i); printf("Bisection: x = %f\n", bisection(xl, xr, t, &poly)); printf("Secant: x = %f\n", secant(xl, xr, t, &poly)); } }
void bisection(double value, double* heap,int hi,int lo){ int middle = (hi+lo)/2; if (middle == hi || middle == lo){ printf("Found it between elements %d %d\n These have values %f %f\n",lo,hi, heap[lo],heap[hi]); return; } if(heap[middle]<value){ //printf("Go into %d to %d\n", middle,hi ); bisection(value,heap,hi,middle); }else{ //printf("Go into %d to %d\n", lo,middle ); bisection(value,heap,middle,lo); } }
int main() { double a, b, e; int status; char chce_podac_x[2]; do { printf("Podaj a: "); scanf("%lf", &a); printf("Podaj b: "); scanf("%lf", &b); if(a < b) { if (f(a) * f(b) < 0) { do { printf("Podaj przybliżenie: "); status = scanf("%lf", &e); if(e > 0 && e < 1) { bisection(a, b, e); newton(a, e); } do { printf("Chcesz podać kolejne przybliżenie? (tak/nie): "); scanf("%s", chce_podac_x); if(strcmp(chce_podac_x, "tak") == 0 || strcmp(chce_podac_x, "nie") == 0) break; } while(1); } while (strcmp(chce_podac_x, "tak") == 0); } else { printf("błąd: f(a) i f(b) muszą mieć różny znak\n"); } } else { printf("błąd: a musi być mniejsze od b\n"); } } while(a >= b || f(a) * f(b) >= 0); return 0; }
double PieceWiseConstant::operator() (double x) const { if (x<xs[lastPos]) { if (lastPos == 0) return ys[0]; // the first one // x < xs[0] else if (x>xs[lastPos-1]) // xs[lp-1] x < xs[lp] return ys[lastPos]; else // x < xs[lp-1] < xs[lp] return bisection(x); } else if (x > xs[n-1]){ std::cout << "x=" << x << std::endl; std::cout << "xs[n-1]=" << xs[n-1] << std::endl; // check if x is reasonable throw("too big than the largest in pieceswiseconstant"); } else // bisection return bisection(x); }
int main(int argc, char **argv){ int order; printf("How many random numbers: 10^"); scanf("%d",&order); int size =(int)pow(10,order); double* heap = calloc(size,sizeof(double*)); srand(time(NULL)); for(int i = 1; i<size ;i++){ double R =(rand()/(RAND_MAX+1.0)); heap[i] = R; //printf("%f\n",R); } heapsort(heap,size); for(int i = 1; i<6 ;i++){ printf("%f \n",heap[i] ); } printf(".........\n"); for(int i = size-7; i<size-1 ;i++){ printf("%f \n",heap[i] ); } bisection(.7,heap,size,0); printf("Number of operations: "); num_ops(); return 0; }
//--------------------------------------------------------------------------- double TfrmCalcParameter::BetaFunction(double* TT, int* day,int ndays,double cover1p, int GrowthZero, double Wmax,double *tm) { double t0=thermalDAP1(TT,day,cover1p,ndays); double te=thermalDAP1(TT,day,GrowthZero,ndays); *tm = bisection(0, te + 10,Wmax,te,t0); return te; }
int main() { printf("\n Dla równania f(x) = 0, gdzie f(x) = 3x + 2 - e^x, wczytać a, b należące"); printf("\n do zbioru liczb rzeczywistych takie, by a < b oraz f(a) * f(b) < 0. Następnie,"); printf("\n dopóki \"użytownik się nie znudzi\", wczytywać wartości 0 < E < 1 i metodą"); printf("\n połowienia na [a, b] przybliżyc z dokładnością E rozwiązanie tego równania."); printf("\n Rozwiązanie to przybliżyc również metodą Newtona z x_0 = a, przy czym, x_k"); printf("\n będzie dobrym przybliżeniem, gdy |x_k - x_(k - 1)| <= E. Porównać ilość"); printf("\n kroków wykonanych metodą połowienia i metodą Newtona.\n"); double a, b; printf("\n Podaj a należące do zbioru liczb rzeczywistych:\n a = "); scanf("%lf", &a); b = a; while(a >= b || equation(a) * equation(b) >= 0) { printf("\n Podaj b należące do zbioru liczb rzeczywistych,\n takie by b > a oraz f(b) * f(a) < 0\n b = "); scanf("%lf", &b); } double epsilon, rB, rN; int choice; while (1) { printf("\n 1 - Przybliż rozwiązanie równania z dokładnością E metodą połowienia i Newtona"); printf("\n 2 - Zakoncz program"); printf("\n Twoj wybor: "); scanf("%i", &choice); switch (choice) { case 1: epsilon = 0; while (epsilon <= 0 || epsilon >= 1) { printf("\n Podaj E, takie by 0 < E < 1:\n E = "); scanf("%lf", &epsilon); } rB = bisection(a, b, epsilon); rN = newton(a, epsilon); printf("\n Metoda połowienia:\n %lf - przybliżone rozwiązanie\n %i - ilość kroków\n", rB, iB); printf("\n Metoda Newtona:\n %lf - przybliżone rozwiązanie\n %i - ilość kroków\n", rN, iN); iB = iN = 0; break; case 2: printf("\n"); return 0; } } }
double bisection(double (*func)(double), double x_l , double x_r){ //make sure x's always bracket root if(bracketed((*func)(x_l), (*func)(x_r))){ //return when four digits or precision are recieved if(fabs(x_r - x_l) < (1/pow(10.0,4.0))){return (x_l + x_r)/2.0; } double x_n = (x_r + x_l)/2.0; //reccur if(bracketed( (*func)(x_l), (*func)(x_n) )){ bisection((*func), x_l, x_n); }else{ bisection((*func), x_n, x_r); } }else{ printf("Something went wrong no longer bracketed\n"); return 0.0; } }
int main(){ while( scanf("%lf %lf %lf %lf %lf %lf", &p, &q, &r, &s, &t, &u ) != EOF ){ if( f(0.0)*f(1.0) > 0.0 ) puts( "No solution" ); else printf( "%.4lf\n", bisection() ); } return 0; }
/** * Finds root in the interval \f$ [t1,t2] \f$. */ int RootFinder::solve(double t1, double t2, double* root) { switch(method) { case BISECTION: return bisection(t1, t2, root); case BRENTS_METHOD: return brents_method(t1, t2, root); case REGULA_FALSI: return regula_falsi(t1, t2, root); default: return false; } }
int main() { //freopen("out.txt","w",stdout); //a and b are the left and right end points double a,b; a = 0.14; b = 0.16; bisection(a,b); return 0; }
double bisection ( // finds root f_(x_) = y_ in [p_, q_] double y_, // f_ (x_) = y_ double (*f_) (double x_), // function double p_, // end-point double q_, // end-point double tol_, // absolute tolerance double rtol_, // relative tolerance Int4 *itmax_) // maximum # of permitted iterations { s_f = f_; return bisection (y_, f, ZERO, p_, q_, tol_, rtol_, itmax_); }
int main(int argc,char *argv[]) { double a,b; if (argc != 3) { fprintf(stderr,"%s <a> <b>\n",argv[0]); exit(1); } a = atof(argv[1]); b = atof(argv[2]); bisection(f,a,b,100,1.0e-7); exit(0); }
int main(){ long n; int test, kase; while( scanf("%d", &test) == 1 ){ for ( kase = 1 ; kase <= test ; kase++ ){ scanf("%ld", &n); printf("Case %d: ", kase); n = bisection(n); if ( n < 0 ) puts("impossible"); else printf("%ld\n", n); } } return 0; }
real robust(real a, real b, fctptr const f, fctptr const df, real const & tol, real const & cfratio, int const & maxit, checkT const & check, int & nit_coarse, int & nit_fine ) { // Call bisection method (with a greater desired tolerance) real tol_bis = cfratio * tol; real x_bis = bisection(a, b, f, tol, maxit, check, nit_coarse); /* Call a Newton algorithm which uses as an initial value the solution given by bisection method */ return newton(x_bis, f, df, tol, maxit, check, nit_fine); }
int sub_iso(std::set<traverse_history_t> A, Graph *Gl) { if(Gl->get_nodes().size() < (*(A.begin())).size()) return 0; int num_of_subisomorphisms = 0; Graph *g1 = new Graph(); Graph *g2 = new Graph(); bisection(Gl, g1, g2); /*printf("~~~~~~G1~~~~~~~~\n"); g1->print(); printf("\n"); printf("~~~~~~G2~~~~~~~~\n"); g2->print(); */ for(std::vector<Node *>::iterator it1 = g1->get_nodes().begin(); it1 != g1->get_nodes().end(); it1++) { for(std::vector<Node *>::iterator it2 = g2->get_nodes().begin(); it2 != g2->get_nodes().end(); it2++) { if((*it1)->is_connected(*it2)) { for(std::set<traverse_history_t>::iterator it3 = A.begin(); it3 != A.end(); it3++){ std::vector<Graph *> S = search_traverse(Gl, *it1, *it2, *it3); num_of_subisomorphisms += S.size(); for(std::vector<Graph *>::iterator it4 = S.begin(); it4 != S.end(); it4++) { printf("-----FOUND------------------------------------------\n"); (*it4)->print(); printf("----------------------------------------------------\n"); } } Gl->set_edge_color((*it1)->get_id(), (*it2)->get_id(), false); Gl->set_edge_color((*it2)->get_id(), (*it1)->get_id(), false); } } } num_of_subisomorphisms += sub_iso(A, g1); num_of_subisomorphisms += sub_iso(A, g2); return num_of_subisomorphisms; }
int sweep_bisection(double (*func)(double x),double xstart,double xstop,double xinc,int nmax,double tol) { double a,b,fa,fb; int retval; xstop = xstop + (xinc * 0.5); a = xstart; fa = (*func)(a); b = a + xinc; while (((xinc > 0.0) && (b < xstop)) || ((xinc < 0.0) && (b > xstop))) { fb = (*func)(b); if ((fa * fb) < 0.0) { /*root bracketed, converge with bisection*/ retval = bisection(func,a,b,nmax,tol); if (retval > 0) return(retval); } a = b; fa = fb; b = b + xinc; } return(0); }
void prox(prob_vars * vars, all_data * data, prox_data * p_data) { memcpy(vars->x_t,vars->x,data->n*(data->T+1)*sizeof(double)); subArray(vars->x_t,vars->z,data->n*(data->T+1)); memcpy(vars->u_t,vars->u,data->m*(data->T+1)*sizeof(double)); subArray(vars->u_t,vars->y,data->m*(data->T+1)); /* The proximal step using bisection (x_t, u_t) */ int idx; #pragma omp parallel for private(idx) for ( int t = 0; t < data->T+1; t++ ) { for ( int j = 0; j < p_data->numsource; j++ ) { idx = t*data->m + p_data->idx_source[j]; /* Saturate the inputs */ vars->u_t[idx] = -fminl(-fminl(vars->u_t[idx],p_data->U), 0); } for ( int i = 0; i < data->n; i++ ){ /* For every node... */ idx = t*data->n+i; bisection(data,&(vars->u_t[t*data->m]), &(vars->x_t[idx]), p_data, i); } } }
int main() { double a, b, x, y1, y2, h, eps = pow(2.0, -30); int n; printf("初期値[a,b]を入力a b\n"); scanf("%lf %lf",&a,&b); printf("区分nを入力\n"); scanf("%d",&n); //bisectionを適用// h = (b-a)/n; y1 = f(a); for(x = a + h;a <= b; x += h) { y2 = f(x); if(y1*y2 < 0.0) { printf("求める答えはx =%f\n",bisection(x-h, x, eps)); } y1 = y2; } return 0; }
/* problem: */ void problem(DomainS *pDomain) { GridS *pG = pDomain->Grid; int i,j,k,n,converged; int is,ie,il,iu,js,je,jl,ju,ks,ke,kl,ku; int nx1, nx2, nx3; Real x1, x2, x3; Real a,b,c,d,xmin,xmax,ymin,ymax; Real x,y,xslow,yslow,xfast,yfast; Real R0,R1,R2,rho,Mdot,K,Omega,Pgas,beta,vR,BR,vphi,Bphi; ConsS *Wind=NULL; Real *pU=NULL,*pUl=NULL,*pUr=NULL; Real lsf,rsf; is = pG->is; ie = pG->ie; nx1 = ie-is+1; js = pG->js; je = pG->je; nx2 = je-js+1; ks = pG->ks; ke = pG->ke; nx3 = ke-ks+1; il = is-nghost*(nx1>1); iu = ie+nghost*(nx1>1); nx1 = iu-il+1; jl = js-nghost*(nx2>1); ju = je+nghost*(nx2>1); nx2 = ju-jl+1; kl = ks-nghost*(nx3>1); ku = ke+nghost*(nx3>1); nx3 = ku-kl+1; #ifndef CYLINDRICAL ath_error("[cylwindrotb]: This problem only works in cylindrical!\n"); #endif #ifndef MHD ath_error("[cylwindrotb]: This problem only works in MHD!\n"); #endif if (nx1==1) { ath_error("[cylwindrotb]: Only R can be used in 1D!\n"); } else if (nx2==1 && nx3>1) { ath_error("[cylwindrotb]: Only (R,phi) can be used in 2D!\n"); } /* Allocate memory for wind solution */ if ((Wind = (ConsS*)calloc_1d_array(nx1+1,sizeof(ConsS))) == NULL) ath_error("[cylwindrotb]: Error allocating memory\n"); /* Allocate memory for grid solution */ if ((RootSoln = (ConsS***)calloc_3d_array(nx3,nx2,nx1,sizeof(ConsS))) == NULL) ath_error("[cylwindrotb]: Error allocating memory\n"); theta = par_getd("problem","theta"); omega = par_getd("problem","omega"); vz = par_getd("problem","vz"); /* This numerical solution was obtained from MATLAB. * Ideally, we replace this with a nonlinear solver... */ xslow = 0.5243264128; yslow = 2.4985859152; xfast = 1.6383327831; yfast = 0.5373957134; E = 7.8744739104; eta = 2.3608500383; xmin = par_getd("domain1","x1min")/R_A; xmax = par_getd("domain1","x1max")/R_A; ymin = 0.45/rho_A; ymax = 2.6/rho_A; printf("theta = %f,\t omega = %f,\t eta = %f,\t E = %f\n", theta,omega,eta,E); printf("xslow = %f,\t yslow = %f,\t xfast = %f,\t yfast = %f\n", xslow,yslow,xfast,yfast); printf("xmin = %f,\t ymin = %f,\t xmax = %f,\t ymax = %f\n", xmin,ymin,xmax,ymax); /* Calculate the 1D wind solution at cell-interfaces */ for (i=il; i<=iu+1; i++) { memset(&(Wind[i]),0.0,sizeof(ConsS)); cc_pos(pG,i,js,ks,&x1,&x2,&x3); /* Want the solution at R-interfaces */ R0 = x1 - 0.5*pG->dx1; x = R0/R_A; /* Look for a sign change interval */ if (x < xslow) { sign_change(myfunc,yslow,10.0*ymax,x,&a,&b); sign_change(myfunc,b,10.0*ymax,x,&a,&b); } else if (x < 1.0) { sign_change(myfunc,1.0+TINY_NUMBER,yslow,x,&a,&b); } else if (x < xfast) { sign_change(myfunc,yfast,1.0-TINY_NUMBER,x,&a,&b); if (!sign_change(myfunc,b,1.0-TINY_NUMBER,x,&a,&b)) { a = yfast; b = 1.0-TINY_NUMBER; } } else { sign_change(myfunc,0.5*ymin,yfast,x,&a,&b); } /* Use bisection to find the root */ converged = bisection(myfunc,a,b,x,&y); if(!converged) { ath_error("[cylwindrotb]: Bisection did not converge!\n"); } /* Construct the solution */ rho = rho_A*y; Mdot = sqrt(R_A*SQR(rho_A)*GM*eta); Omega = sqrt((GM*omega)/pow(R_A,3)); K = (GM*theta)/(Gamma*pow(rho_A,Gamma_1)*R_A); Pgas = K*pow(rho,Gamma); vR = Mdot/(R0*rho); beta = sqrt(1.0/rho_A); BR = beta*rho*vR; vphi = R0*Omega*(1.0/SQR(x)-y)/(1.0-y); Bphi = beta*rho*(vphi-R0*Omega); Wind[i].d = rho; Wind[i].M1 = rho*vR; Wind[i].M2 = rho*vphi; Wind[i].M3 = rho*vz; Wind[i].B1c = BR; Wind[i].B2c = Bphi; Wind[i].B3c = 0.0; Wind[i].E = Pgas/Gamma_1 + 0.5*(SQR(Wind[i].B1c) + SQR(Wind[i].B2c) + SQR(Wind[i].B3c)) + 0.5*(SQR(Wind[i].M1 ) + SQR(Wind[i].M2 ) + SQR(Wind[i].M3 ))/Wind[i].d; } /* Average the wind solution across the zone for cc variables */ for (i=il; i<=iu; i++) { memset(&(pG->U[ks][js][i]),0.0,sizeof(ConsS)); cc_pos(pG,i,js,ks,&x1,&x2,&x3); lsf = (x1 - 0.5*pG->dx1)/x1; rsf = (x1 + 0.5*pG->dx1)/x1; pU = (Real*)&(pG->U[ks][js][i]); pUl = (Real*)&(Wind[i]); pUr = (Real*)&(Wind[i+1]); for (n=0; n<NWAVE; n++) { pU[n] = 0.5*(lsf*pUl[n] + rsf*pUr[n]); } pG->B1i[ks][js][i] = Wind[i].B1c; pG->B2i[ks][js][i] = 0.5*(lsf*Wind[i].B2c + rsf*Wind[i+1].B2c); pG->B3i[ks][js][i] = 0.5*(lsf*Wind[i].B3c + rsf*Wind[i+1].B3c); } /* Copy 1D solution across the grid and save */ for (k=kl; k<=ku; k++) { for (j=jl; j<=ju; j++) { for (i=il; i<=iu; i++) { pG->U[k][j][i] = pG->U[ks][js][i]; pG->B1i[k][j][i] = pG->B1i[ks][js][i]; pG->B2i[k][j][i] = pG->B2i[ks][js][i]; pG->B3i[k][j][i] = pG->B3i[ks][js][i]; RootSoln[k][j][i] = pG->U[ks][js][i]; } } } StaticGravPot = grav_pot; bvals_mhd_fun(pDomain,left_x1,do_nothing_bc); bvals_mhd_fun(pDomain,right_x1,do_nothing_bc); free_1d_array((void *)Wind); return; }
int TTVFast(double *params,double dt, double Time, double total,int n_plan,CalcTransit *transit,CalcRV *RV_struct, int nRV, int n_events, int input_flag) { n_planets=n_plan; int planet; int i, j; j=0; void jacobi_heliocentric(PhaseState *jacobi, PhaseState *helio, double GMsun, double *GM); double dot0,dot1,dot2,rskyA,rskyB,vprojA,vprojB,rsky,vproj,velocity,new_dt; double compute_RV(PhaseState *ps); double compute_deriv(PhaseState ps,int planet); int RV_count = 0; int k=0; double deriv; double dt2 = dt/2.0; if(RV_struct !=NULL){ RV_count = nRV; } machine_epsilon = determine_machine_epsilon(); if(input_flag ==0){ read_jacobi_planet_elements(params); } if(input_flag ==1){ read_helio_planet_elements(params); } if(input_flag ==2){ read_helio_cartesian_params(params); } if(input_flag !=0 && input_flag !=1 && input_flag !=2){ printf("Input flag must be 0,1, or 2. \n"); //exit(-1); return FAILURE; } copy_system(p, rp); compute_corrector_coefficientsTO(dt); real_to_mapTO(rp, p); for(i = 0;i<n_planets;i++){ prev_dot[i] = p[i].x*p[i].xd+p[i].y*p[i].yd; count[i]=0; } if (A(p, dt2) != SUCCESS) return FAILURE; while(Time < total){ copy_system(p, p_tmp); B(p,dt); if( A(p,dt) != SUCCESS) return FAILURE; Time+=dt; /* Calculate RV if necessary */ if(j <RV_count){ RVTime = Time+dt2; if(RVTime>(RV_struct+j)->time && RVTime-dt<(RV_struct+j)->time){ if(RVTime-(RV_struct+j)->time > (RV_struct+j)->time-(RVTime-dt)){ copy_system(p_tmp,p_RV); new_dt= (RV_struct+j)->time-(RVTime-dt); if( A(p,dt) != SUCCESS) return FAILURE; velocity = compute_RV(p_RV); (RV_struct+j)->RV =velocity; }else{ copy_system(p,p_RV); new_dt= (RV_struct+j)->time-RVTime; if( A(p,dt) != SUCCESS) return FAILURE; velocity = compute_RV(p_RV); (RV_struct+j)->RV =velocity; } j++; } } /* now look for transits */ for(i = 0;i<n_planets;i++){ /* for each planet */ curr_dot[i] = p[i].x*p[i].xd+p[i].y*p[i].yd; curr_z[i] = p[i].z; tplanet=i; /* Check Transit Condition*/ if(prev_dot[tplanet]<0 && curr_dot[tplanet]>0 && curr_z[tplanet]>0){ bad_transit_flag = 0; copy_system(p,p_ahead); copy_system(p_tmp,p_behind); if (A(p_ahead,-dt2) != SUCCESS) return FAILURE ; if (A(p_behind,-dt2) !=SUCCESS) return FAILURE ; jacobi_heliocentric(p_behind,helioBehind,GMsun,GM); jacobi_heliocentric(p_ahead,helioAhead,GMsun,GM); /* Calculate Rsky.Vsky */ dot2 = helioAhead[tplanet].x*helioAhead[tplanet].xd+helioAhead[tplanet].y*helioAhead[tplanet].yd; dot1 = helioBehind[tplanet].x*helioBehind[tplanet].xd+helioBehind[tplanet].y*helioBehind[tplanet].yd; if(dot1 < 0 && dot2 >0){ /* If Rsky.Vsky passed through zero*/ TimeA=Time; TimeB = Time-dt; dotA= TimeA+kepler_transit_locator(kc_helio[tplanet],-dt,&helioAhead[tplanet],&temporary); deriv = compute_deriv(temporary,tplanet); if(deriv < 0.0 || temporary.z <0.0 || dotA < TimeB-PI/mm[tplanet] || dotA > TimeA+PI/mm[tplanet]){ /* was the right root found?*/ dotA= TimeA+bisection(kc_helio[tplanet],&helioAhead[tplanet],&helioBehind[tplanet],&temporary); } rskyA = sqrt(temporary.x*temporary.x + temporary.y*temporary.y); vprojA = sqrt(temporary.xd*temporary.xd + temporary.yd*temporary.yd); dotB= TimeB+kepler_transit_locator(kc_helio[tplanet],dt,&helioBehind[tplanet],&temporary); deriv = compute_deriv(temporary,tplanet); if(deriv < 0.0 || temporary.z <0.0 || dotB < TimeB-PI/mm[tplanet] || dotB > TimeA+PI/mm[tplanet]){ /* was the right root found?*/ dotB= TimeB+bisection(kc_helio[tplanet],&helioBehind[tplanet],&helioAhead[tplanet],&temporary); } rskyB = sqrt(temporary.x*temporary.x + temporary.y*temporary.y); vprojB = sqrt(temporary.xd*temporary.xd + temporary.yd*temporary.yd); tdot_result = ((dotB-TimeB)*dotA+(TimeA-dotA)*dotB)/(TimeA-TimeB-dotA+dotB); rsky = ((dotB-TimeB)*rskyA+(TimeA-dotA)*rskyB)/(TimeA-TimeB-dotA+dotB); vproj = ((dotB-TimeB)*vprojA+(TimeA-dotA)*vprojB)/(TimeA-TimeB-dotA+dotB); }else{ copy_system(helioAhead,helioBehind); copy_system(p,p_ahead); B(p_ahead,dt); if (A(p_ahead,dt2) != SUCCESS) return FAILURE; TimeA=Time+dt; TimeB = Time; jacobi_heliocentric(p_ahead,helioAhead,GMsun,GM); dotB= TimeB+kepler_transit_locator(kc_helio[tplanet],dt,&helioBehind[tplanet],&temporary); deriv = compute_deriv(temporary,tplanet); if(deriv < 0.0 || temporary.z <0.0 || dotB < TimeB-PI/mm[tplanet] || dotB > TimeA+PI/mm[tplanet]){ /* was the right root found?*/ dotB= TimeB+bisection(kc_helio[tplanet],&helioBehind[tplanet],&helioAhead[tplanet],&temporary); } rskyB = sqrt(temporary.x*temporary.x + temporary.y*temporary.y); vprojB = sqrt(temporary.xd*temporary.xd + temporary.yd*temporary.yd); dotA= TimeA+kepler_transit_locator(kc_helio[tplanet],-dt,&helioAhead[tplanet],&temporary); deriv = compute_deriv(temporary,tplanet); if(deriv < 0.0 || temporary.z <0.0 || dotA < TimeB-PI/mm[tplanet] || dotA > TimeA+PI/mm[tplanet]){ /* was the right root found?*/ dotA= TimeA+bisection(kc_helio[tplanet],&helioAhead[tplanet],&helioBehind[tplanet],&temporary); } rskyA = sqrt(temporary.x*temporary.x + temporary.y*temporary.y); vprojA = sqrt(temporary.xd*temporary.xd + temporary.yd*temporary.yd); tdot_result = ((dotB-TimeB)*dotA+(TimeA-dotA)*dotB)/(TimeA-TimeB-dotA+dotB); rsky = ((dotB-TimeB)*rskyA+(TimeA-dotA)*rskyB)/(TimeA-TimeB-dotA+dotB); vproj = ((dotB-TimeB)*vprojA+(TimeA-dotA)*vprojB)/(TimeA-TimeB-dotA+dotB); } if(k< n_events){ if(bad_transit_flag ==0){ (transit+k)->planet = tplanet; (transit+k)->epoch = count[tplanet]; (transit+k)->time = tdot_result; (transit+k)->rsky = rsky; (transit+k)->vsky = vproj; }else{ (transit+k)->planet = tplanet; (transit+k)->epoch = count[tplanet]; (transit+k)->time = BAD_TRANSIT; (transit+k)->rsky = BAD_TRANSIT; (transit+k)->vsky = BAD_TRANSIT; } count[tplanet]++; k++; }else{ printf("Not enough memory allocated for Transit structure: more events triggering as transits than expected. Possibily indicative of larger problem.\n"); //exit(-1); return FAILURE; } } prev_dot[i]=curr_dot[i]; } } return SUCCESS; }
/* problem: */ void problem(DomainS *pDomain) { GridS *pG = pDomain->Grid; int i,j,k; int is,ie,il,iu,js,je,jl,ju,ks,ke,kl,ku; int nx1,nx2,nx3; Real x1,x2,x3; Real xs,vs,v,pgas0,pgas,alpha,beta,a,b,converged; is = pG->is; ie = pG->ie; nx1 = ie-is+1; js = pG->js; je = pG->je; nx2 = je-js+1; ks = pG->ks; ke = pG->ke; nx3 = ke-ks+1; il = is-nghost*(nx1>1); iu = ie+nghost*(nx1>1); nx1 = iu-il+1; jl = js-nghost*(nx2>1); ju = je+nghost*(nx2>1); nx2 = ju-jl+1; kl = ks-nghost*(nx3>1); ku = ke+nghost*(nx3>1); nx3 = ku-kl+1; #ifdef MHD ath_error("[cylwindrot]: This problem only works in hydro!\n"); #endif #ifndef CYLINDRICAL ath_error("[cylwindrot]: This problem only works in cylindrical!\n"); #endif if (nx1==1) { ath_error("[cylwindrot]: This problem can only be run in 2D or 3D!\n"); } else if (nx2==1 && nx3>1) { ath_error("[cylwindrot]: Only (R,phi) can be used in 2D!\n"); } /* Allocate memory for solution */ if ((RootSoln = (ConsS***)calloc_3d_array(nx3,nx2,nx1,sizeof(ConsS))) == NULL) ath_error("[cylwindrot]: Error allocating memory for solution\n"); ang_mom = par_getd("problem","ang_mom"); c_infty = par_getd("problem","c_infty"); vz0 = par_getd("problem","vz0"); iprob = par_geti("problem","iprob"); printf("gamma = %f,\t ang_mom = %f,\t c_infty = %f\n", Gamma, ang_mom, c_infty); beta = 2.0*Gamma_1/(Gamma+1.0); xs = (3.0-Gamma+sqrt(SQR(Gamma-3.0)-16.0*SQR(ang_mom)))/4.0; lambda_s = 1.0/Gamma_1*pow(xs,beta)+pow(xs,beta-1.0)-0.5*SQR(ang_mom)*pow(xs,beta-2.0); lambda_s = pow(lambda_s/(0.5+1.0/Gamma_1),1.0/beta); vs = c_infty*pow(lambda_s/xs,0.5*beta); printf("xs = %13.10f,\t lambda_s = %13.10f,\t vs = %13.10f\n", xs, lambda_s, vs); // Compute 1D wind/accretion solution for (i=il; i<=iu; i++) { cc_pos(pG,i,j,k,&x1,&x2,&x3); memset(&(pG->U[ks][js][i]),0.0,sizeof(ConsS)); vs = pow(lambda_s/x1,0.5*beta); switch(iprob) { case 1: /* Wind */ if (x1 < xs) { a = TINY_NUMBER; b = vs; } else { a = vs; b = HUGE_NUMBER; } break; case 2: /* Accretion */ if (x1 < xs) { a = vs; b = HUGE_NUMBER; } else { a = TINY_NUMBER; b = vs; } break; default: ath_error("[cylwindrot]: Not an accepted problem number!\n"); } converged = bisection(myfunc,a,b,x1,&v); if (!converged) ath_error("[cylwindrot]: Bisection did not converge!\n"); pG->U[ks][js][i].d = lambda_s/(x1*v); pG->U[ks][js][i].M1 = lambda_s/x1; if (iprob==2) pG->U[ks][js][i].M1 *= -1.0; pG->U[ks][js][i].M2 = pG->U[ks][js][i].d*ang_mom/x1; pG->U[ks][js][i].M3 = pG->U[ks][js][i].d*vz0; /* Initialize total energy */ #ifndef ISOTHERMAL pgas0 = 1.0/Gamma; pgas = pgas0*pow(pG->U[ks][js][i].d,Gamma); pG->U[ks][js][i].E = pgas/Gamma_1 + 0.5*(SQR(pG->U[ks][js][i].M1) + SQR(pG->U[ks][js][i].M2) + SQR(pG->U[ks][js][i].M3))/pG->U[ks][js][i].d; #endif /* ISOTHERMAL */ } /* Copy 1D solution and save */ for (k=kl; k<=ku; k++) { for (j=jl; j<=ju; j++) { for (i=il; i<=iu; i++) { pG->U[k][j][i] = pG->U[ks][js][i]; RootSoln[k][j][i] = pG->U[ks][js][i]; } } } StaticGravPot = grav_pot; bvals_mhd_fun(pDomain,left_x1,do_nothing_bc); bvals_mhd_fun(pDomain,right_x1,do_nothing_bc); return; }
int main() { FILE *fp = fopen("BigShips_1280x720_60Hz_i420_part1_result.csv","w"); double sheet1[600][3]; //用于存储600条QP、Bits、Y PSNR数据 double sheet2[600][3]; double sheet3[600][3]; double sheet4[600][3]; double QP[8]; double R[8]; double D[8]; double lambda[8]; double alpha[4]; double beta[4]; double c[4]; double k[4]; double Rbudget = 2000.0; //2000kb/s double u; //u=1/μ double low = -10000.0; //二分法求公式(10)的解,区间下限 double high = 20000.0; //二分法求公式(10)的解,区间上限 int framerate = 60; int imageWidth = 1280; int imageHeight = 720; parseCSV("BigShips_1280x720_60Hz_i420_part1.csv", sheet1, framerate, imageWidth, imageHeight); //解析CSV文件,将600行R、D、QP存入sheet数组 parseCSV("BigShips_1280x720_60Hz_i420_part2.csv", sheet2, framerate, imageWidth, imageHeight); parseCSV("City_corr_1280x720_60Hz_i420_part1.csv", sheet3, framerate, imageWidth, imageHeight); parseCSV("City_corr_1280x720_60Hz_i420_part2.csv", sheet4, framerate, imageWidth, imageHeight); for (int i = 0; i < 600; i ++) { for (int j = 0; j < 2; j++) { QP[j] = sheet1[i + j][0]; R[j] = sheet1[i + j][1]; D[j] = sheet1[i + j][2]; QP[j+2] = sheet2[i + j][0]; R[j+2] = sheet2[i + j][1]; D[j+2] = sheet2[i + j][2]; QP[j+4] = sheet3[i + j][0]; R[j+4] = sheet3[i + j][1]; D[j+4] = sheet3[i + j][2]; QP[j+6] = sheet4[i + j][0]; R[j+6] = sheet4[i + j][1]; D[j+6] = sheet4[i + j][2]; } for (int j = 0; j < 4; j++) { lambda[j * 2] = exp((QP[j * 2] - 13.7122) / 4.2005); //用两个QP(对应两个Lamda), 编码出两个R,对应两个D(R) lambda[j * 2 + 1] = exp((QP[j * 2 + 1] - 13.7122) / 4.2005); beta[j] = log(R[j * 2] / R[j * 2 + 1]) / log(lambda[j * 2] / lambda[j * 2 + 1]); //把 α 和 β 求解出来 alpha[j] = R[j * 2] / pow(lambda[j * 2], beta[j]); k[j] = -log(D[j * 2] / D[j * 2 + 1]) / log(R[j * 2] / R[j * 2 + 1]); //把c k 求解出来 c[j] = D[j * 2] / pow(R[j * 2], -k[j]); } u = bisection(Rbudget, high, low, c, k); //二分法求公式10的解 fprintf(fp, "R,lambda,QP\n"); //即将保存的数据的表头:R lambda QP for (int j = 0; j < 4; j++) { R[j] = pow(k[j] * c[j] * u, 1 / (k[j] + 1)); //利用Mu把各对c_i k_i 的 R_i算出来 lambda[j] = pow(R[j] / alpha[j], 1 / beta[j]); //利用R_i, 重新求解出λ_i QP[j] = 4.2005*log(lambda[j]) + 13.7122; //利用λ_i重新求解出QP_i fprintf(fp, "%lf,%lf,%lf\n", R[j], lambda[j], QP[j]); //保存数据 } } return 0; }
void surftempskin() { int tskiniter; int tskinitermax; /* float tkel = 273.16; */ /*0 point of water in K*/ double dtsurf,dtsurf1; double tsurf,tsurfold,tsurfold1; turbfluxes(); /* printf("A %f %f ",jd2,surftemp[i][j]);*/ tsurf = surftemp[i][j]; /* in deg C*/ tsurf1 = surftemp[i][j] - tinterv; tsurf2 = surftemp[i][j] + tinterv; dtsurf = 2.*taccur; dtsurf1 = 2.*taccur; tsurfold = tsurf1; tskiniter = 0; tskinitermax = 40; while ((dtsurf > taccur) && (dtsurf1 > 0.)) { tskiniter = tskiniter+1; tsurfold1 = tsurfold; tsurfold = tsurf; bisection(); tsurf = tbisection; if (tsurf >= 0.) tsurf = 0.; tspechum = tsurf; kspechum = 2; spechum(); surftemp[i][j] = tsurf; turbfluxes(); // tsurfenergybalance(tsurf); if (tsurf >= 0.) tsurfenergybalance(0.); sourceskin = balancetsurf; if (sourceskin < 0.) sourceskin = 0.; dtsurf = fabs(tsurf - tsurfold); dtsurf1 = fabs(tsurf - tsurfold1); if ( tskiniter >= tskinitermax) { /* no solution found */ fprintf(outcontrol," function surftempskin: more than %d iterations necessary %f %f %f %f %f \n", tskinitermax,taccur,dtsurf,tsurf,tsurfold,sourceskin); tsurf = 0.5 * (tsurf + tsurfold); dtsurf = 0.; } } if ((dtsurf > taccur) && (dtsurf1 == 0.) && (tskiniter > tskinitermax)) { /* no solution found */ fprintf(outcontrol," function surftempskin: nosolution found, varies between: %d %f %f %f %f \n", tskiniter,taccur,dtsurf,tsurf,tsurfold); tsurf = 0.5 * (tsurf + tsurfold); } surftemp[i][j] = tsurf; return; }
PolygonalMesh* Polygonizer::computeSurfaceNetSIG02(float epsilon, float tau) { float p[3]; bool ***isIn = new bool**[dimZ+1]; bool ***isValid = new bool**[dimZ+1]; for(int i=0; i<dimZ+1; i++){ isIn[i] = new bool*[dimY+1]; isValid[i] = new bool*[dimY+1]; p[2] = originZ + i*spaceZ; for(int j=0; j<dimY+1; j++){ isIn[i][j] = new bool[dimX+1]; isValid[i][j] = new bool[dimX+1]; p[1] = originY + j*spaceY; for(int k=0; k<dimX+1; k++){ p[0] = originX + k*spaceX; isIn[i][j][k] = (func->value(p[0], p[1], p[2], isValid[i][j][k]) > 0); } } } int ***index = new int**[dimZ+1]; for(int i=0; i<dimZ+1; i++){ index[i] = new int*[dimY+1]; for(int j=0; j<dimY+1; j++){ index[i][j] = new int[dimX+1]; for(int k=0; k<dimX+1; k++) index[i][j][k] = -1; } } int current = 0; int face_N = 0; for(int i=0; i<dimZ; i++) for(int j=0; j<dimY; j++) for(int k=0; k<dimX-1; k++){ if(!isValid[i][j][k] || !isValid[i][j][k+1]) continue; if((!isIn[i][j][k] && isIn[i][j][k+1]) || (isIn[i][j][k] && !isIn[i][j][k+1])){ face_N++; if(index[i][j][k+1] < 0){ index[i][j][k+1] = current; current++; } if(index[i][j+1][k+1] < 0){ index[i][j+1][k+1] = current; current++; } if(index[i+1][j][k+1] < 0){ index[i+1][j][k+1] = current; current++; } if(index[i+1][j+1][k+1] < 0){ index[i+1][j+1][k+1] = current; current++; } } } for(int i=0; i<dimX; i++) for(int j=0; j<dimZ; j++) for(int k=0; k<dimY-1; k++){ if(!isValid[j][k][i] || !isValid[j][k+1][i]) continue; if((!isIn[j][k][i] && isIn[j][k+1][i]) || (isIn[j][k][i] && !isIn[j][k+1][i])){ face_N++; if(index[j][k+1][i] < 0){ index[j][k+1][i] = current; current++; } if(index[j+1][k+1][i] < 0){ index[j+1][k+1][i] = current; current++; } if(index[j][k+1][i+1] < 0){ index[j][k+1][i+1] = current; current++; } if(index[j+1][k+1][i+1] < 0){ index[j+1][k+1][i+1] = current; current++; } } } for(int i=0; i<dimY; i++) for(int j=0; j<dimX; j++) for(int k=0; k<dimZ-1; k++){ if(!isValid[k][i][j] || !isValid[k+1][i][j]) continue; if((!isIn[k][i][j] && isIn[k+1][i][j]) || (isIn[k][i][j] && !isIn[k+1][i][j])){ face_N++; if(index[k+1][i][j] < 0){ index[k+1][i][j] = current; current++; } if(index[k+1][i+1][j] < 0){ index[k+1][i+1][j] = current; current++; } if(index[k+1][i][j+1] < 0){ index[k+1][i][j+1] = current; current++; } if(index[k+1][i+1][j+1] < 0){ index[k+1][i+1][j+1] = current; current++; } } } PolygonalMesh* mesh = new PolygonalMesh; int vertex_N = current; mesh->setVertexCount(vertex_N); float (*vertex)[3] = mesh->vertex; int* degree = mesh->degree_f = new int[vertex_N]; current = 0; for(int i=0; i<vertex_N; i++){ vertex[i][0] = vertex[i][1] = vertex[i][2] = 0; degree[i] = 0; } /* for(i=0; i<dimZ+1; i++) for(int j=0; j<dimY+1; j++) for(int k=0; k<dimX+1; k++) if(index[i][j][k] >= 0){ index[i][j][k] = current; vertex[current][0] = spaceX*((float)k-0.5f) + originX; vertex[current][1] = spaceY*((float)j-0.5f) + originY; vertex[current][2] = spaceZ*((float)i-0.5f) + originZ; current++; } */ mesh->setFaceCount(face_N); double (*Q)[10] = new double[vertex_N][10]; for(int i=0; i<vertex_N; i++) MAT_INIT(Q[i]); for(int i=0; i<face_N; i++) mesh->setPolygonCount(i, 4); face_N = 0; int **face = mesh->face; bool flag = false; for(int i=0; i<dimZ; i++) for(int j=0; j<dimY; j++) for(int k=0; k<dimX-1; k++){ if(!isValid[i][j][k] || !isValid[i][j][k+1]) continue; if(isIn[i][j][k] && !isIn[i][j][k+1]){ face[face_N][0] = index[i][j][k+1]; face[face_N][1] = index[i][j+1][k+1]; face[face_N][2] = index[i+1][j+1][k+1]; face[face_N][3] = index[i+1][j][k+1]; face_N++; flag = true; } else if(!isIn[i][j][k] && isIn[i][j][k+1]){ face[face_N][0] = index[i][j][k+1]; face[face_N][1] = index[i+1][j][k+1]; face[face_N][2] = index[i+1][j+1][k+1]; face[face_N][3] = index[i][j+1][k+1]; face_N++; flag = true; } if(!flag) continue; flag = false; float p[3], s[3], e[3]; s[0] = originX + k*spaceX; e[0] = originX + (k+1)*spaceX; s[1] = e[1] = originY + j*spaceY; s[2] = e[2] = originZ + i*spaceZ; bisection(p, s, e, epsilon); float g[3]; func->gradient(g, p[0], p[1], p[2]); double len = PolygonalMesh::LENGTH(g); //if((float)len == 0) //continue; double nor[3]; nor[0] = g[0]/len; nor[1] = g[1]/len; nor[2] = g[2]/len; double d = -PolygonalMesh::DOT(nor, p); double Q_tmp[10]; MATRIX(Q_tmp, nor, d); int i0 = index[i][j][k+1]; MAT_SUM(Q[i0], Q_tmp); vertex[i0][0] += p[0]; vertex[i0][1] += p[1]; vertex[i0][2] += p[2]; degree[i0]++; i0 = index[i][j+1][k+1]; MAT_SUM(Q[i0], Q_tmp); vertex[i0][0] += p[0]; vertex[i0][1] += p[1]; vertex[i0][2] += p[2]; degree[i0]++; i0 = index[i+1][j+1][k+1]; MAT_SUM(Q[i0], Q_tmp); vertex[i0][0] += p[0]; vertex[i0][1] += p[1]; vertex[i0][2] += p[2]; degree[i0]++; i0 = index[i+1][j][k+1]; MAT_SUM(Q[i0], Q_tmp); vertex[i0][0] += p[0]; vertex[i0][1] += p[1]; vertex[i0][2] += p[2]; degree[i0]++; } for(int i=0; i<dimX; i++) for(int j=0; j<dimZ; j++) for(int k=0; k<dimY-1; k++){ if(!isValid[j][k][i] || !isValid[j][k+1][i]) continue; if(isIn[j][k][i] && !isIn[j][k+1][i]){ face[face_N][0] = index[j][k+1][i]; face[face_N][1] = index[j+1][k+1][i]; face[face_N][2] = index[j+1][k+1][i+1]; face[face_N][3] = index[j][k+1][i+1]; face_N++; flag = true; } else if(!isIn[j][k][i] && isIn[j][k+1][i]){ face[face_N][0] = index[j][k+1][i]; face[face_N][1] = index[j][k+1][i+1]; face[face_N][2] = index[j+1][k+1][i+1]; face[face_N][3] = index[j+1][k+1][i]; face_N++; flag = true; } if(!flag) continue; flag = false; float p[3], s[3], e[3]; s[1] = originY + k*spaceY; e[1] = originY + (k+1)*spaceY; s[2] = e[2] = originZ + j*spaceZ; s[0] = e[0] = originX + i*spaceX; bisection(p, s, e, epsilon); float g[3]; func->gradient(g, p[0], p[1], p[2]); double len = PolygonalMesh::LENGTH(g); //if((float)len == 0) //continue; double nor[3]; nor[0] = g[0]/len; nor[1] = g[1]/len; nor[2] = g[2]/len; double d = -PolygonalMesh::DOT(nor, p); double Q_tmp[10]; MATRIX(Q_tmp, nor, d); int i0 = index[j][k+1][i]; MAT_SUM(Q[i0], Q_tmp); vertex[i0][0] += p[0]; vertex[i0][1] += p[1]; vertex[i0][2] += p[2]; degree[i0]++; i0 = index[j+1][k+1][i]; MAT_SUM(Q[i0], Q_tmp); vertex[i0][0] += p[0]; vertex[i0][1] += p[1]; vertex[i0][2] += p[2]; degree[i0]++; i0 = index[j+1][k+1][i+1]; MAT_SUM(Q[i0], Q_tmp); vertex[i0][0] += p[0]; vertex[i0][1] += p[1]; vertex[i0][2] += p[2]; degree[i0]++; i0 = index[j][k+1][i+1]; MAT_SUM(Q[i0], Q_tmp); vertex[i0][0] += p[0]; vertex[i0][1] += p[1]; vertex[i0][2] += p[2]; degree[i0]++; } for(int i=0; i<dimY; i++) for(int j=0; j<dimX; j++) for(int k=0; k<dimZ-1; k++){ if(!isValid[k][i][j] || !isValid[k+1][i][j]) continue; if(isIn[k][i][j] && !isIn[k+1][i][j]){ face[face_N][0] = index[k+1][i][j]; face[face_N][1] = index[k+1][i][j+1]; face[face_N][2] = index[k+1][i+1][j+1]; face[face_N][3] = index[k+1][i+1][j]; face_N++; flag = true; } else if(!isIn[k][i][j] && isIn[k+1][i][j]){ face[face_N][0] = index[k+1][i][j]; face[face_N][1] = index[k+1][i+1][j]; face[face_N][2] = index[k+1][i+1][j+1]; face[face_N][3] = index[k+1][i][j+1]; face_N++; flag = true; } if(!flag) continue; flag = false; float p[3], s[3], e[3]; s[2] = originZ + k*spaceZ; e[2] = originZ + (k+1)*spaceZ; s[0] = e[0] = originX + j*spaceX; s[1] = e[1] = originY + i*spaceY; bisection(p, s, e, epsilon); float g[3]; func->gradient(g, p[0], p[1], p[2]); double len = PolygonalMesh::LENGTH(g); //if((float)len == 0) //continue; double nor[3]; nor[0] = g[0]/len; nor[1] = g[1]/len; nor[2] = g[2]/len; double d = -PolygonalMesh::DOT(nor, p); double Q_tmp[10]; MATRIX(Q_tmp, nor, d); int i0 = index[k+1][i][j]; MAT_SUM(Q[i0], Q_tmp); vertex[i0][0] += p[0]; vertex[i0][1] += p[1]; vertex[i0][2] += p[2]; degree[i0]++; i0 = index[k+1][i][j+1]; MAT_SUM(Q[i0], Q_tmp); vertex[i0][0] += p[0]; vertex[i0][1] += p[1]; vertex[i0][2] += p[2]; degree[i0]++; i0 = index[k+1][i+1][j+1]; MAT_SUM(Q[i0], Q_tmp); vertex[i0][0] += p[0]; vertex[i0][1] += p[1]; vertex[i0][2] += p[2]; degree[i0]++; i0 = index[k+1][i+1][j]; MAT_SUM(Q[i0], Q_tmp); vertex[i0][0] += p[0]; vertex[i0][1] += p[1]; vertex[i0][2] += p[2]; degree[i0]++; } //FOR SVD vnl_matrix< float > A( 3, 3, 0. ); vnl_vector< float > b(3, 0.), x(3, 0.); for(int i=0; i<vertex_N; i++){ if(degree[i] == 0) continue; vertex[i][0] /= degree[i]; vertex[i][1] /= degree[i]; vertex[i][2] /= degree[i]; continue; A[0][0] = (float)Q[i][0]; A[1][0] = A[0][1] = (float)Q[i][1]; A[2][0] = A[0][2] = (float)Q[i][2]; A[1][1] = (float)Q[i][3]; A[1][2] = A[2][1] = (float)Q[i][4]; A[2][2] = (float)Q[i][5]; float Av[3]; MAT_BY_VEC(Av, Q[i], vertex[i]); b[0] = -(float)Q[i][6] - Av[0]; b[1] = -(float)Q[i][7] - Av[1]; b[2] = -(float)Q[i][8] - Av[2]; vnl_svd<float> svd( A ); svd.zero_out_absolute( 0.0000001 ); x = svd.solve( b ); if(fabs(x[1]) > spaceX || fabs(x[2]) > spaceY || fabs(x[3]) > spaceZ) continue; mesh->vertex[i][0] += x[1]; mesh->vertex[i][1] += x[2]; mesh->vertex[i][2] += x[3]; } for(int i=0; i<dimZ+1; i++){ for(int j=0; j<dimY+1; j++){ delete[] isIn[i][j]; delete[] index[i][j]; } delete[] isIn[i]; delete[] index[i]; } delete[] isIn; delete[] index; delete[] Q; delete[] isValid; return mesh; }
int main(int argc, char* argv[]) { int input[] = { 5, -1, 4, 12 }; int input_size = 4; int input_sorted[] = { -4, 1, 22, 66, 89, 120, 238 }; int input_sorted_size = 7; // 2. function pointers // direct invocation printf("Max is %d\n", max(input, input_size)); // function pointer invocation int(*sortfunc)(int elements[], int size) = max; printf("Max (function pointer) %d\n", sortfunc(input, input_size)); // 3. recursivity printf("recursive fibonacci(12) = %d\n", fibonacci_recursive(12)); printf("iterative fibonacci(12) = %d\n", fibonacci_iterative(12)); // 4. search // 4a. simple search harness_search(input, input_size, 4, "search", search); harness_search(input, input_size, 2, "search", search); // 4b. binary search harness_search(input_sorted, input_sorted_size, 89, "search_binary", search_binary); harness_search(input_sorted, input_sorted_size, 500, "search_binary", search_binary); harness_search(input_sorted, input_sorted_size, -40, "search_binary", search_binary); harness_search(input_sorted, input_sorted_size, 140, "search_binary", search_binary); // 4. merge int to_sort[] = { 9, -1, 3, 11, 4, 99, 11, 0 }; int to_sort_size = 8; printf("Performing merge sort\n"); printf("- unsorted: "); print_array(to_sort, to_sort_size); sort_merge(to_sort, to_sort_size); printf("- sorted: "); print_array(to_sort, to_sort_size); // 5. file access int matrix[4][4] = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { -1, -2, -3, -4 }, { 9, 78, 12, -1 } }; write_matrix_to_file(matrix, "matrix.txt"); int matrix_out[4][4]; read_matrix_from_file(matrix_out, "matrix.txt"); printf("Matrix read from file:\n"); print_matrix(matrix_out); // 6/7. binary file access // delete 'db' before using unlink("students.dat"); STUDENT student1; student1.an_studiu = 1; student1.grupa = 1014; student1.nume = "Salut"; STUDENT student2; student2.an_studiu = 2; student2.grupa = 1084; student2.nume = "Pa"; student_append(student1, "students.dat"); student_append(student2, "students.dat"); student_print_all("students.dat"); // XX. bisection method // f(x) = x^3 - x - 2 // f(1) = -2 // f(2) = -4 int res = bisection(1, 2, equation); printf("Bisected x to be %d\n", res); printf("GCD: %d\n", gcd(299792458, 6447287)); return EXIT_SUCCESS; }
//Do intial guesses need to be found int main(int argc, char **argv){ printf("Root 1 %.4f \n",bisection(poly_function,0,1)); printf("Root 2 %.4f\n", bisection(poly_function,-3,-2)); printf("Root 3 %.4f\n", bisection(poly_function,1,2)); return 0; }