int
gsl_multifit_fdfridge_wset (gsl_multifit_fdfridge * w,
gsl_multifit_function_fdf * f,
const gsl_vector * x,
const double lambda,
const gsl_vector * wts)
{
const size_t n = w->n;
const size_t p = w->p;
if (n != f->n || p != f->p)
{
GSL_ERROR ("function size does not match solver", GSL_EBADLEN);
}
else if (p != x->size)
{
GSL_ERROR ("vector length does not match solver", GSL_EBADLEN);
}
else if (wts != NULL && n != wts->size)
{
GSL_ERROR ("weight vector length does not match solver", GSL_EBADLEN);
}
else
{
int status;
gsl_vector_view wv = gsl_vector_subvector(w->wts, 0, n);
/* save user defined fdf */
w->fdf = f;
/* build modified fdf for Tikhonov terms */
w->fdftik.f = &fdfridge_f;
w->fdftik.df = &fdfridge_df;
w->fdftik.n = n + p; /* add p for Tikhonov terms */
w->fdftik.p = p;
w->fdftik.params = (void *) w;
/* store damping parameter */
w->lambda = lambda;
w->L = NULL;
if (wts)
{
/* copy weight vector into user portion of w->wts */
gsl_vector_memcpy(&wv.vector, wts);
status = gsl_multifit_fdfsolver_wset(w->s, &(w->fdftik), x, w->wts);
}
else
{
status = gsl_multifit_fdfsolver_wset(w->s, &(w->fdftik), x, NULL);
}
/* update function/Jacobian evaluations */
f->nevalf = w->fdftik.nevalf;
f->nevaldf = w->fdftik.nevaldf;
return status;
}
} /* gsl_multifit_fdfridge_wset() */
int
main (void)
{
const gsl_multifit_fdfsolver_type *T = gsl_multifit_fdfsolver_lmsder;
gsl_multifit_fdfsolver *s;
int status, info;
size_t i;
const size_t n = N;
const size_t p = 3;
gsl_matrix *J = gsl_matrix_alloc(n, p);
gsl_matrix *covar = gsl_matrix_alloc (p, p);
double y[N], weights[N];
struct data d = { n, y };
gsl_multifit_function_fdf f;
double x_init[3] = { 1.0, 0.0, 0.0 };
gsl_vector_view x = gsl_vector_view_array (x_init, p);
gsl_vector_view w = gsl_vector_view_array(weights, n);
const gsl_rng_type * type;
gsl_rng * r;
gsl_vector *res_f;
double chi, chi0;
const double xtol = 1e-8;
const double gtol = 1e-8;
const double ftol = 0.0;
gsl_rng_env_setup();
type = gsl_rng_default;
r = gsl_rng_alloc (type);
f.f = &expb_f;
f.df = &expb_df; /* set to NULL for finite-difference Jacobian */
f.n = n;
f.p = p;
f.params = &d;
/* This is the data to be fitted */
for (i = 0; i < n; i++)
{
double t = i;
double yi = 1.0 + 5 * exp (-0.1 * t);
double si = 0.1 * yi;
double dy = gsl_ran_gaussian(r, si);
weights[i] = 1.0 / (si * si);
y[i] = yi + dy;
printf ("data: %zu %g %g\n", i, y[i], si);
};
s = gsl_multifit_fdfsolver_alloc (T, n, p);
/* initialize solver with starting point and weights */
gsl_multifit_fdfsolver_wset (s, &f, &x.vector, &w.vector);
/* compute initial residual norm */
res_f = gsl_multifit_fdfsolver_residual(s);
chi0 = gsl_blas_dnrm2(res_f);
/* solve the system with a maximum of 20 iterations */
status = gsl_multifit_fdfsolver_driver(s, 20, xtol, gtol, ftol, &info);
gsl_multifit_fdfsolver_jac(s, J);
gsl_multifit_covar (J, 0.0, covar);
/* compute final residual norm */
chi = gsl_blas_dnrm2(res_f);
#define FIT(i) gsl_vector_get(s->x, i)
#define ERR(i) sqrt(gsl_matrix_get(covar,i,i))
fprintf(stderr, "summary from method '%s'\n",
gsl_multifit_fdfsolver_name(s));
fprintf(stderr, "number of iterations: %zu\n",
gsl_multifit_fdfsolver_niter(s));
fprintf(stderr, "function evaluations: %zu\n", f.nevalf);
fprintf(stderr, "Jacobian evaluations: %zu\n", f.nevaldf);
fprintf(stderr, "reason for stopping: %s\n",
(info == 1) ? "small step size" : "small gradient");
fprintf(stderr, "initial |f(x)| = %g\n", chi0);
fprintf(stderr, "final |f(x)| = %g\n", chi);
{
double dof = n - p;
double c = GSL_MAX_DBL(1, chi / sqrt(dof));
fprintf(stderr, "chisq/dof = %g\n", pow(chi, 2.0) / dof);
fprintf (stderr, "A = %.5f +/- %.5f\n", FIT(0), c*ERR(0));
fprintf (stderr, "lambda = %.5f +/- %.5f\n", FIT(1), c*ERR(1));
fprintf (stderr, "b = %.5f +/- %.5f\n", FIT(2), c*ERR(2));
}
fprintf (stderr, "status = %s\n", gsl_strerror (status));
gsl_multifit_fdfsolver_free (s);
gsl_matrix_free (covar);
gsl_matrix_free (J);
gsl_rng_free (r);
return 0;
}
static void
test_fdf(const gsl_multifit_fdfsolver_type * T, const double xtol,
const double gtol, const double ftol,
const double epsrel, const double x0_scale,
test_fdf_problem *problem,
const double *wts)
{
gsl_multifit_function_fdf *fdf = problem->fdf;
const size_t n = fdf->n;
const size_t p = fdf->p;
const size_t max_iter = 1500;
gsl_vector *x0 = gsl_vector_alloc(p);
gsl_vector_view x0v = gsl_vector_view_array(problem->x0, p);
gsl_multifit_fdfsolver *s = gsl_multifit_fdfsolver_alloc (T, n, p);
const char *pname = problem->name;
char sname[2048];
int status, info;
sprintf(sname, "%s/scale=%g%s",
gsl_multifit_fdfsolver_name(s), x0_scale,
problem->fdf->df ? "" : "/fdiff");
/* scale starting point x0 */
gsl_vector_memcpy(x0, &x0v.vector);
test_scale_x0(x0, x0_scale);
if (wts)
{
gsl_vector_const_view wv = gsl_vector_const_view_array(wts, n);
gsl_multifit_fdfsolver_wset(s, fdf, x0, &wv.vector);
}
else
gsl_multifit_fdfsolver_set(s, fdf, x0);
status = gsl_multifit_fdfsolver_driver(s, max_iter, xtol, gtol,
ftol, &info);
gsl_test(status, "%s/%s did not converge, status=%s",
sname, pname, gsl_strerror(status));
/* check solution */
test_fdf_checksol(sname, pname, epsrel, s, problem);
if (wts == NULL)
{
/* test again with weighting matrix W = I */
gsl_vector *wv = gsl_vector_alloc(n);
sprintf(sname, "%s/scale=%g%s/weights",
gsl_multifit_fdfsolver_name(s), x0_scale,
problem->fdf->df ? "" : "/fdiff");
gsl_vector_memcpy(x0, &x0v.vector);
test_scale_x0(x0, x0_scale);
gsl_vector_set_all(wv, 1.0);
gsl_multifit_fdfsolver_wset(s, fdf, x0, wv);
status = gsl_multifit_fdfsolver_driver(s, max_iter, xtol, gtol,
ftol, &info);
gsl_test(status, "%s/%s did not converge, status=%s",
sname, pname, gsl_strerror(status));
test_fdf_checksol(sname, pname, epsrel, s, problem);
gsl_vector_free(wv);
}
gsl_multifit_fdfsolver_free(s);
gsl_vector_free(x0);
}
