double f_inverse(const double fx, double x) { // x is the initial guess of the root f(x)=fx gsl_function_fdf fdf; fdf.f= &solver_f; fdf.df= &solver_df; fdf.fdf= &solver_fdf; fdf.params= (void*) &fx; gsl_root_fdfsolver_set(solver, &fdf, x); int iter= 0, status; double x0; do { iter++; status= gsl_root_fdfsolver_iterate(solver); x0= x; x= gsl_root_fdfsolver_root(solver); status= gsl_root_test_delta(x, x0, 0, 1.0e-6); if(status == GSL_SUCCESS) break; } while(status == GSL_CONTINUE && iter < 100); double fx_check= f(x); assert(fabs(fx - fx_check) < 1.0e-4); return x; }
double intersection_point() { gsl_root_fdfsolver* s; odesolver_t funcsolver; gsl_function_fdf fdf = {.f = &func, .df = &dfunc, .fdf = &func_fdf, .params = &funcsolver}; double x0, x=0.; ode_alloc(&funcsolver); s = gsl_root_fdfsolver_alloc(gsl_root_fdfsolver_steffenson); gsl_root_fdfsolver_set(s, &fdf, x); int status; do { gsl_root_fdfsolver_iterate(s); x0 = x; x = gsl_root_fdfsolver_root(s); status = gsl_root_test_delta(x, x0, 0, 1e-12); } while(status == GSL_CONTINUE); double root = gsl_root_fdfsolver_root(s); gsl_root_fdfsolver_free(s); ode_free(&funcsolver); if(status == GSL_SUCCESS) return root; else return -1.; }
double tsolve_findroot_E(struct Tsolve * theTsolve){ int status; int iter = 0, max_iter = 100; const gsl_root_fdfsolver_type *T; gsl_root_fdfsolver *s; gsl_function_fdf FDF; T = gsl_root_fdfsolver_newton; s = gsl_root_fdfsolver_alloc (T); FDF.f = &tsolve_E_eq; FDF.df = &tsolve_E_eq_deriv; FDF.fdf = &tsolve_E_eq_fdf; FDF.params = theTsolve; double Temp0; //store previous iteration value double Temp = theTsolve->guess; // set initial guess here gsl_root_fdfsolver_set (s, &FDF, Temp); do { iter++; status = gsl_root_fdfsolver_iterate (s); Temp0 = Temp; Temp = gsl_root_fdfsolver_root (s); status = gsl_root_test_delta (Temp, Temp0, 0, 1e-12); } while (status == GSL_CONTINUE && iter < max_iter); gsl_root_fdfsolver_free (s); return(Temp); }
void test_fdf_e (const gsl_root_fdfsolver_type * T, const char * description, gsl_function_fdf *fdf, double root, double correct_root) { int status; size_t iterations = 0; double prev = 0 ; gsl_root_fdfsolver * s = gsl_root_fdfsolver_alloc(T); status = gsl_root_fdfsolver_set (s, fdf, root) ; gsl_test (status, "%s (set), %s", T->name, description); do { iterations++ ; prev = gsl_root_fdfsolver_root(s); gsl_root_fdfsolver_iterate (s); status = gsl_root_test_delta(gsl_root_fdfsolver_root(s), prev, EPSABS, EPSREL); } while (status == GSL_CONTINUE && iterations < MAX_ITERATIONS); gsl_test (!status, "%s, %s", gsl_root_fdfsolver_name(s), description, gsl_root_fdfsolver_root(s) - correct_root); gsl_root_fdfsolver_free(s); }
static VALUE rb_gsl_fdfsolver_solve(int argc, VALUE *argv, VALUE *obj) { gsl_root_fdfsolver *s = NULL; double x = 0.0, x0, epsabs = 0.0, epsrel = 1e-6; gsl_function_fdf *F = NULL; int status, iter = 0, max_iter = 100; switch (argc) { case 3: Check_Type(argv[2], T_ARRAY); epsabs = NUM2DBL(rb_ary_entry(argv[2], 0)); epsrel = NUM2DBL(rb_ary_entry(argv[2], 1)); /* no break */ case 2: Need_Float(argv[1]); x0 = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "Usage: solve(f = Function, range = Array, eps = Array)"); break; } CHECK_FUNCTION_FDF(argv[0]); Data_Get_Struct(argv[0], gsl_function_fdf, F); Data_Get_Struct(obj, gsl_root_fdfsolver, s); gsl_root_fdfsolver_set(s, F, x0); do { iter++; status = gsl_root_fdfsolver_iterate (s); x0 = x; x = gsl_root_fdfsolver_root (s); status = gsl_root_test_delta(x, x0, epsabs, epsrel); if (status == GSL_SUCCESS) break; } while (status == GSL_CONTINUE && iter < max_iter); return rb_ary_new3(3, rb_float_new(x), INT2FIX(iter), INT2FIX(status)); }
static double a_of_chi(double chi,Csm_params *cpar,double *a_old,gsl_root_fdfsolver *s) { if(chi==0) return 1.; else { Fpar p; gsl_function_fdf FDF; double a_previous,a_current=*a_old; p.cpar=cpar; p.chi=chi; FDF.f=&fzero; FDF.df=&dfzero; FDF.fdf=&fdfzero; FDF.params=&p; gsl_root_fdfsolver_set(s,&FDF,a_current); int iter=0,status; do { iter++; status=gsl_root_fdfsolver_iterate(s); a_previous=a_current; a_current=gsl_root_fdfsolver_root(s); status=gsl_root_test_delta(a_current,a_previous,1E-6,0); } while(status==GSL_CONTINUE); *a_old=a_current; return a_current; } }
CAMLprim value ml_gsl_root_fdfsolver_set(value s, value f, value r) { CAMLparam1(s); struct callback_params *p=Fparams_val(s); p->closure=f; gsl_root_fdfsolver_set(FDFsolver_val(s), &(p->gslfun.gfdf), Double_val(r)); CAMLreturn(Val_unit); }
static VALUE rb_gsl_fdfsolver_set(VALUE obj, VALUE func, VALUE r) { gsl_root_fdfsolver *s = NULL; gsl_function_fdf *fff = NULL; double root; CHECK_FUNCTION_FDF(func); Data_Get_Struct(obj, gsl_root_fdfsolver, s); Data_Get_Struct(func, gsl_function_fdf, fff); root = NUM2DBL(r); gsl_root_fdfsolver_set(s, fff, root); return obj; }
double fun_root (void *params) { int status; int iter = 0, max_iter = 100; int i; const gsl_root_fdfsolver_type *T; gsl_root_fdfsolver *s; double x0, x, y; gsl_function_fdf FDF_ri; struct fun_root_params *p = (struct fun_root_params *) params; FDF_ri.f = &fun_ri; FDF_ri.df = &fun_ri_deriv; FDF_ri.fdf = &fun_ri_fdf; FDF_ri.params = p; x = p->rf; T = gsl_root_fdfsolver_secant; s = gsl_root_fdfsolver_alloc (T); gsl_root_fdfsolver_set (s, &FDF_ri, x); do { iter++; status = gsl_root_fdfsolver_iterate (s); x0 = x; x = gsl_root_fdfsolver_root (s); status = gsl_root_test_delta (x, x0, 0, 0.0000001); // printf ("%5d %10.7f %10.7f\n", // iter, x, x - x0); } while (status == GSL_CONTINUE && iter < max_iter); // printf ("%5d %10.7f %10.7f %10.7f\n", // iter, p->rf, x, x - x0); y = x; gsl_root_fdfsolver_free (s); return y; }
void test_fdf (const gsl_root_fdfsolver_type * T, const char * description, gsl_function_fdf *fdf, double root, double correct_root) { int status; size_t iterations = 0; double prev = 0 ; gsl_root_fdfsolver * s = gsl_root_fdfsolver_alloc(T); gsl_root_fdfsolver_set (s, fdf, root) ; do { iterations++ ; prev = gsl_root_fdfsolver_root(s); gsl_root_fdfsolver_iterate (s); status = gsl_root_test_delta(gsl_root_fdfsolver_root(s), prev, EPSABS, EPSREL); } while (status == GSL_CONTINUE && iterations < MAX_ITERATIONS); gsl_test (status, "%s, %s (%g obs vs %g expected) ", gsl_root_fdfsolver_name(s), description, gsl_root_fdfsolver_root(s), correct_root); if (iterations == MAX_ITERATIONS) { gsl_test (GSL_FAILURE, "exceeded maximum number of iterations"); } /* check the validity of the returned result */ if (!WITHIN_TOL (gsl_root_fdfsolver_root(s), correct_root, EPSREL, EPSABS)) { gsl_test (GSL_FAILURE, "incorrect precision (%g obs vs %g expected)", gsl_root_fdfsolver_root(s), correct_root); } gsl_root_fdfsolver_free(s); }
int main () { int status; int iterations = 0, max_iterations = 100; gsl_root_fdfsolver *s; double x0, x = 5.0, r_expected = sqrt (5.0); gsl_function_fdf FDF; struct quadratic_params params = {1.0, 0.0, -5.0}; FDF.f = &quadratic; FDF.df = &quadratic_deriv; FDF.fdf = &quadratic_fdf; FDF.params = ¶ms; s = gsl_root_fdfsolver_alloc (gsl_root_fdfsolver_newton); gsl_root_fdfsolver_set (s, &FDF, x); printf ("using %s method\n", gsl_root_fdfsolver_name (s)); printf ("%-5s %10s %10s %10s %10s\n", "iter", "root", "actual", "err", "err(est)"); do { iterations++; status = gsl_root_fdfsolver_iterate (s); x0 = x; x = gsl_root_fdfsolver_root (s); status = gsl_root_test_delta (x, x0, 0, 0.001); if (status == GSL_SUCCESS) printf ("Converged:\n"); printf ("%5d %10.7f %10.7f %+10.7f %10.7f\n", iterations, x, r_expected, x - r_expected, x - x0); } while (status == GSL_CONTINUE && iterations < max_iterations); }