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); }