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.;
}
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);
}
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 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);
}
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;
}
}
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);
}
static VALUE rb_gsl_fdfsolver_iterate(VALUE obj)
{
gsl_root_fdfsolver *s = NULL;
Data_Get_Struct(obj, gsl_root_fdfsolver, s);
return INT2FIX(gsl_root_fdfsolver_iterate(s));
}
