static void
test_fdf_main(const gsl_multifit_nlinear_parameters * params)
{
const double xtol = pow(GSL_DBL_EPSILON, 0.9);
const double gtol = pow(GSL_DBL_EPSILON, 0.9);
const double ftol = 0.0;
size_t i;
for (i = 0; test_problems[i] != NULL; ++i)
{
test_fdf_problem *problem = test_problems[i];
double epsrel = *(problem->epsrel);
gsl_multifit_nlinear_fdf fdf;
test_fdf(gsl_multifit_nlinear_trust, params, xtol, gtol, ftol,
epsrel, problem, NULL);
/* test finite difference Jacobian
* XXX: watson problem doesn't work with forward differences */
if (problem != &watson_problem)
{
fdf.df = problem->fdf->df;
problem->fdf->df = NULL;
test_fdf(gsl_multifit_nlinear_trust, params, xtol, gtol, ftol,
1.0e3 * epsrel, problem, NULL);
problem->fdf->df = fdf.df;
}
#if 1 /*XXX: box3d test fails on MacOS here */
if (params->trs == gsl_multifit_nlinear_trs_lmaccel && problem->fdf->fvv != NULL)
{
/* test finite difference second directional derivative */
fdf.fvv = problem->fdf->fvv;
problem->fdf->fvv = NULL;
test_fdf(gsl_multifit_nlinear_trust, params, xtol, gtol, ftol,
epsrel / params->h_fvv, problem, NULL);
problem->fdf->fvv = fdf.fvv;
}
#endif
}
/* test weighted nonlinear least squares */
/* internal weighting in _f and _df functions */
test_fdf(gsl_multifit_nlinear_trust, params, xtol, gtol, ftol,
wnlin_epsrel, &wnlin_problem1, NULL);
/* weighting through nlinear_winit */
test_fdf(gsl_multifit_nlinear_trust, params, xtol, gtol, ftol,
wnlin_epsrel, &wnlin_problem2, wnlin_W);
}
static void
test_fdf_main(const gsl_multilarge_nlinear_parameters * params)
{
const double xtol = pow(GSL_DBL_EPSILON, 0.9);
const double gtol = pow(GSL_DBL_EPSILON, 0.9);
const double ftol = 0.0;
size_t i;
for (i = 0; test_problems[i] != NULL; ++i)
{
test_fdf_problem *problem = test_problems[i];
double epsrel = *(problem->epsrel);
gsl_multilarge_nlinear_fdf fdf;
/*XXX: finite difference fvv not working yet */
if (problem->fdf->fvv == NULL)
continue;
test_fdf(gsl_multilarge_nlinear_trust, params, xtol, gtol, ftol,
epsrel, 1.0, problem, NULL);
#if 0 /* XXX */
/* test finite difference Jacobian */
fdf.df = problem->fdf->df;
problem->fdf->df = NULL;
test_fdf(gsl_multilarge_nlinear_trust, params, xtol, gtol, ftol,
1.0e3 * epsrel, 1.0, problem, NULL);
problem->fdf->df = fdf.df;
#endif
#if 0
if (params->trs == gsl_multilarge_nlinear_trs_lmaccel && problem->fdf->fvv != NULL)
{
/* test finite difference second directional derivative */
fdf.fvv = problem->fdf->fvv;
problem->fdf->fvv = NULL;
test_fdf(gsl_multilarge_nlinear_trust, params, xtol, gtol, ftol,
epsrel / params->h_fvv, 1.0, problem, NULL);
problem->fdf->fvv = fdf.fvv;
}
#endif
}
/* test weighted nonlinear least squares */
/* internal weighting in _f and _df functions */
test_fdf(gsl_multilarge_nlinear_trust, params, xtol, gtol, ftol,
wnlin_epsrel, 1.0, &wnlin_problem1, NULL);
}
int
main (void)
{
gsl_ieee_env_setup();
test_longley();
test_filip();
test_pontius();
{
gsl_multifit_function_fdf f = make_fdf (&brown_f, &brown_df, &brown_fdf,
brown_N, brown_P, 0);
test_lmder(&f, brown_x0, &brown_X[0][0], brown_F, &brown_cov[0][0]);
}
{
gsl_multifit_function_fdf f = make_fdf (&enso_f, &enso_df, &enso_fdf,
enso_N, enso_P, 0);
test_fdf("nist-ENSO", &f, enso_x0, enso_x, enso_sumsq, enso_sigma);
}
{
gsl_multifit_function_fdf f = make_fdf (&kirby2_f, &kirby2_df, &kirby2_fdf,
kirby2_N, kirby2_P, 0);
test_fdf("nist-kirby2", &f, kirby2_x0, kirby2_x, kirby2_sumsq, kirby2_sigma);
}
{
gsl_multifit_function_fdf f = make_fdf (&hahn1_f, &hahn1_df, &hahn1_fdf,
hahn1_N, hahn1_P, 0);
test_fdf("nist-hahn1", &f, hahn1_x0, hahn1_x, hahn1_sumsq, hahn1_sigma);
}
#ifdef JUNK
{
gsl_multifit_function_fdf f = make_fdf (&nelson_f, &nelson_df, &nelson_fdf,
nelson_N, nelson_P, 0);
test_fdf("nist-nelson", &f, nelson_x0, nelson_x, nelson_sumsq, nelson_sigma);
}
#endif
/* now summarize the results */
exit (gsl_test_summary ());
}
int
main (void)
{
const gsl_multimin_fdfminimizer_type *fdfminimizers[5];
const gsl_multimin_fdfminimizer_type ** T;
gsl_ieee_env_setup ();
fdfminimizers[0] = gsl_multimin_fdfminimizer_steepest_descent;
fdfminimizers[1] = gsl_multimin_fdfminimizer_conjugate_pr;
fdfminimizers[2] = gsl_multimin_fdfminimizer_conjugate_fr;
fdfminimizers[3] = gsl_multimin_fdfminimizer_vector_bfgs;
fdfminimizers[4] = 0;
T = fdfminimizers;
while (*T != 0)
{
test_fdf("Roth", &roth, roth_initpt,*T);
test_fdf("Wood", &wood, wood_initpt,*T);
test_fdf("Rosenbrock", &rosenbrock, rosenbrock_initpt,*T);
T++;
}
T = fdfminimizers;
while (*T != 0)
{
test_fdf("NRoth", &Nroth, roth_initpt,*T);
test_fdf("NWood", &Nwood, wood_initpt,*T);
test_fdf("NRosenbrock", &Nrosenbrock, rosenbrock_initpt,*T);
T++;
}
exit (gsl_test_summary());
}
int
main (void)
{
gsl_function F_sin, F_cos, F_func1, F_func2, F_func3, F_func4,
F_func5, F_func6;
gsl_function_fdf FDF_sin, FDF_cos, FDF_func1, FDF_func2, FDF_func3, FDF_func4,
FDF_func5, FDF_func6;
const gsl_root_fsolver_type * fsolver[4] ;
const gsl_root_fdfsolver_type * fdfsolver[4] ;
const gsl_root_fsolver_type ** T;
const gsl_root_fdfsolver_type ** S;
gsl_ieee_env_setup();
fsolver[0] = gsl_root_fsolver_bisection;
fsolver[1] = gsl_root_fsolver_brent;
fsolver[2] = gsl_root_fsolver_falsepos;
fsolver[3] = 0;
fdfsolver[0] = gsl_root_fdfsolver_newton;
fdfsolver[1] = gsl_root_fdfsolver_secant;
fdfsolver[2] = gsl_root_fdfsolver_steffenson;
fdfsolver[3] = 0;
F_sin = create_function (sin_f) ;
F_cos = create_function (cos_f) ;
F_func1 = create_function (func1) ;
F_func2 = create_function (func2) ;
F_func3 = create_function (func3) ;
F_func4 = create_function (func4) ;
F_func5 = create_function (func5) ;
F_func6 = create_function (func6) ;
FDF_sin = create_fdf (sin_f, sin_df, sin_fdf) ;
FDF_cos = create_fdf (cos_f, cos_df, cos_fdf) ;
FDF_func1 = create_fdf (func1, func1_df, func1_fdf) ;
FDF_func2 = create_fdf (func2, func2_df, func2_fdf) ;
FDF_func3 = create_fdf (func3, func3_df, func3_fdf) ;
FDF_func4 = create_fdf (func4, func4_df, func4_fdf) ;
FDF_func5 = create_fdf (func5, func5_df, func5_fdf) ;
FDF_func6 = create_fdf (func6, func6_df, func6_fdf) ;
gsl_set_error_handler (&my_error_handler);
for (T = fsolver ; *T != 0 ; T++)
{
test_f (*T, "sin(x) [3, 4]", &F_sin, 3.0, 4.0, M_PI);
test_f (*T, "sin(x) [-4, -3]", &F_sin, -4.0, -3.0, -M_PI);
test_f (*T, "sin(x) [-1/3, 1]", &F_sin, -1.0 / 3.0, 1.0, 0.0);
test_f (*T, "cos(x) [0, 3]", &F_cos, 0.0, 3.0, M_PI / 2.0);
test_f (*T, "cos(x) [-3, 0]", &F_cos, -3.0, 0.0, -M_PI / 2.0);
test_f (*T, "x^20 - 1 [0.1, 2]", &F_func1, 0.1, 2.0, 1.0);
test_f (*T, "sqrt(|x|)*sgn(x)", &F_func2, -1.0 / 3.0, 1.0, 0.0);
test_f (*T, "x^2 - 1e-8 [0, 1]", &F_func3, 0.0, 1.0, sqrt (1e-8));
test_f (*T, "x exp(-x) [-1/3, 2]", &F_func4, -1.0 / 3.0, 2.0, 0.0);
test_f (*T, "(x - 1)^7 [0.9995, 1.0002]", &F_func6, 0.9995, 1.0002, 1.0);
test_f_e (*T, "invalid range check [4, 0]", &F_sin, 4.0, 0.0, M_PI);
test_f_e (*T, "invalid range check [1, 1]", &F_sin, 1.0, 1.0, M_PI);
test_f_e (*T, "invalid range check [0.1, 0.2]", &F_sin, 0.1, 0.2, M_PI);
}
for (S = fdfsolver ; *S != 0 ; S++)
{
test_fdf (*S,"sin(x) {3.4}", &FDF_sin, 3.4, M_PI);
test_fdf (*S,"sin(x) {-3.3}", &FDF_sin, -3.3, -M_PI);
test_fdf (*S,"sin(x) {0.5}", &FDF_sin, 0.5, 0.0);
test_fdf (*S,"cos(x) {0.6}", &FDF_cos, 0.6, M_PI / 2.0);
test_fdf (*S,"cos(x) {-2.5}", &FDF_cos, -2.5, -M_PI / 2.0);
test_fdf (*S,"x^{20} - 1 {0.9}", &FDF_func1, 0.9, 1.0);
test_fdf (*S,"x^{20} - 1 {1.1}", &FDF_func1, 1.1, 1.0);
test_fdf (*S,"sqrt(|x|)*sgn(x) {1.001}", &FDF_func2, 0.001, 0.0);
test_fdf (*S,"x^2 - 1e-8 {1}", &FDF_func3, 1.0, sqrt (1e-8));
test_fdf (*S,"x exp(-x) {-2}", &FDF_func4, -2.0, 0.0);
test_fdf_e (*S,"max iterations x -> +Inf, x exp(-x) {2}", &FDF_func4, 2.0, 0.0);
test_fdf_e (*S,"max iterations x -> -Inf, 1/(1 + exp(-x)) {0}", &FDF_func5, 0.0, 0.0);
}
test_fdf (gsl_root_fdfsolver_steffenson,
"(x - 1)^7 {0.9}", &FDF_func6, 0.9, 1.0);
/* now summarize the results */
exit (gsl_test_summary ());
}
int
main (void)
{
gsl_ieee_env_setup ();
{
const gsl_multimin_fdfminimizer_type *fdfminimizers[6];
const gsl_multimin_fdfminimizer_type ** T;
fdfminimizers[0] = gsl_multimin_fdfminimizer_steepest_descent;
fdfminimizers[1] = gsl_multimin_fdfminimizer_conjugate_pr;
fdfminimizers[2] = gsl_multimin_fdfminimizer_conjugate_fr;
fdfminimizers[3] = gsl_multimin_fdfminimizer_vector_bfgs;
fdfminimizers[4] = gsl_multimin_fdfminimizer_vector_bfgs2;
fdfminimizers[5] = 0;
T = fdfminimizers;
while (*T != 0)
{
test_fdf("Roth", &roth, roth_initpt,*T);
test_fdf("Wood", &wood, wood_initpt,*T);
test_fdf("Rosenbrock", &rosenbrock, rosenbrock_initpt,*T);
test_fdf("Rosenbrock1", &rosenbrock, rosenbrock_initpt1,*T);
test_fdf("SimpleAbs", &simpleabs, simpleabs_initpt,*T);
T++;
}
T = fdfminimizers;
while (*T != 0)
{
test_fdf("NRoth", &Nroth, roth_initpt,*T);
test_fdf("NWood", &Nwood, wood_initpt,*T);
test_fdf("NRosenbrock", &Nrosenbrock, rosenbrock_initpt,*T);
T++;
}
}
{
const gsl_multimin_fminimizer_type *fminimizers[4];
const gsl_multimin_fminimizer_type ** T;
fminimizers[0] = gsl_multimin_fminimizer_nmsimplex;
fminimizers[1] = gsl_multimin_fminimizer_nmsimplex2;
fminimizers[2] = gsl_multimin_fminimizer_nmsimplex2rand;
fminimizers[3] = 0;
T = fminimizers;
while (*T != 0)
{
test_f("Roth", &roth_fmin, roth_initpt,*T);
test_f("Wood", &wood_fmin, wood_initpt,*T);
test_f("Rosenbrock", &rosenbrock_fmin, rosenbrock_initpt,*T);
test_f("Spring", &spring_fmin, spring_initpt,*T);
T++;
}
}
exit (gsl_test_summary());
}
static void
test_nonlinear(void)
{
const double xtol = pow(GSL_DBL_EPSILON, 0.9);
const double gtol = pow(GSL_DBL_EPSILON, 0.9);
const double ftol = 0.0;
size_t i, j;
/* Nielsen tests */
for (i = 0; test_fdf_nielsen[i] != NULL; ++i)
{
test_fdf_problem *problem = test_fdf_nielsen[i];
double epsrel = *(problem->epsrel);
double scale = 1.0;
for (j = 0; j < problem->ntries; ++j)
{
double eps_scale = epsrel * scale;
test_fdf(gsl_multifit_fdfsolver_lmsder, xtol, gtol, ftol,
eps_scale, scale, problem, NULL);
test_fdfridge(gsl_multifit_fdfsolver_lmsder, xtol, gtol, ftol,
eps_scale, scale, problem, NULL);
/* test finite difference Jacobian */
{
gsl_multifit_function_fdf fdf;
fdf.df = problem->fdf->df;
problem->fdf->df = NULL;
test_fdf(gsl_multifit_fdfsolver_lmsder, xtol, gtol, ftol,
1.0e5 * eps_scale, 1.0, problem, NULL);
test_fdfridge(gsl_multifit_fdfsolver_lmsder, xtol, gtol, ftol,
1.0e5 * eps_scale, 1.0, problem, NULL);
problem->fdf->df = fdf.df;
}
scale *= 10.0;
}
test_fdf(gsl_multifit_fdfsolver_lmniel, xtol, gtol, ftol,
10.0 * epsrel, 1.0, problem, NULL);
}
/* More tests */
for (i = 0; test_fdf_more[i] != NULL; ++i)
{
test_fdf_problem *problem = test_fdf_more[i];
double epsrel = *(problem->epsrel);
double scale = 1.0;
for (j = 0; j < problem->ntries; ++j)
{
double eps_scale = epsrel * scale;
test_fdf(gsl_multifit_fdfsolver_lmsder, xtol, gtol, ftol,
eps_scale, scale, problem, NULL);
test_fdfridge(gsl_multifit_fdfsolver_lmsder, xtol, gtol, ftol,
eps_scale, scale, problem, NULL);
/* test finite difference Jacobian */
{
gsl_multifit_function_fdf fdf;
fdf.df = problem->fdf->df;
problem->fdf->df = NULL;
test_fdf(gsl_multifit_fdfsolver_lmsder, xtol, gtol, ftol,
1.0e5 * eps_scale, 1.0, problem, NULL);
test_fdfridge(gsl_multifit_fdfsolver_lmsder, xtol, gtol, ftol,
1.0e5 * eps_scale, 1.0, problem, NULL);
problem->fdf->df = fdf.df;
}
scale *= 10.0;
}
test_fdf(gsl_multifit_fdfsolver_lmniel, xtol, gtol, ftol,
10.0 * epsrel, 1.0, problem, NULL);
}
/* NIST tests */
for (i = 0; test_fdf_nist[i] != NULL; ++i)
{
test_fdf_problem *problem = test_fdf_nist[i];
double epsrel = *(problem->epsrel);
double scale = 1.0;
for (j = 0; j < problem->ntries; ++j)
{
double eps_scale = epsrel * scale;
test_fdf(gsl_multifit_fdfsolver_lmsder, xtol, gtol, ftol,
eps_scale, scale, problem, NULL);
test_fdf(gsl_multifit_fdfsolver_lmder, xtol, gtol, ftol,
eps_scale, scale, problem, NULL);
/* test finite difference Jacobian */
{
gsl_multifit_function_fdf fdf;
fdf.df = problem->fdf->df;
problem->fdf->df = NULL;
test_fdf(gsl_multifit_fdfsolver_lmsder, xtol, gtol, ftol,
eps_scale, 1.0, problem, NULL);
test_fdf(gsl_multifit_fdfsolver_lmder, xtol, gtol, ftol,
eps_scale, scale, problem, NULL);
problem->fdf->df = fdf.df;
}
scale *= 10.0;
}
test_fdf(gsl_multifit_fdfsolver_lmniel, xtol, gtol, ftol,
epsrel, 1.0, problem, NULL);
}
/* test weighted nonlinear least squares */
/* internal weighting in _f and _df functions */
test_fdf(gsl_multifit_fdfsolver_lmsder, xtol, gtol, ftol,
wnlin_epsrel, 1.0, &wnlin_problem1, NULL);
test_fdf(gsl_multifit_fdfsolver_lmniel, xtol, gtol, ftol,
wnlin_epsrel, 1.0, &wnlin_problem1, NULL);
test_fdfridge(gsl_multifit_fdfsolver_lmsder, xtol, gtol, ftol,
wnlin_epsrel, 1.0, &wnlin_problem1, NULL);
test_fdfridge(gsl_multifit_fdfsolver_lmniel, xtol, gtol, ftol,
wnlin_epsrel, 1.0, &wnlin_problem1, NULL);
/* weighting through fdfsolver_wset */
test_fdf(gsl_multifit_fdfsolver_lmsder, xtol, gtol, ftol,
wnlin_epsrel, 1.0, &wnlin_problem2, wnlin_W);
test_fdf(gsl_multifit_fdfsolver_lmniel, xtol, gtol, ftol,
wnlin_epsrel, 1.0, &wnlin_problem2, wnlin_W);
test_fdfridge(gsl_multifit_fdfsolver_lmsder, xtol, gtol, ftol,
wnlin_epsrel, 1.0, &wnlin_problem2, wnlin_W);
test_fdfridge(gsl_multifit_fdfsolver_lmniel, xtol, gtol, ftol,
wnlin_epsrel, 1.0, &wnlin_problem2, wnlin_W);
}
int
main (void)
{
const gsl_multiroot_fsolver_type * fsolvers[5] ;
const gsl_multiroot_fsolver_type ** T1 ;
const gsl_multiroot_fdfsolver_type * fdfsolvers[5] ;
const gsl_multiroot_fdfsolver_type ** T2 ;
double f;
fsolvers[0] = gsl_multiroot_fsolver_dnewton;
fsolvers[1] = gsl_multiroot_fsolver_broyden;
fsolvers[2] = gsl_multiroot_fsolver_hybrid;
fsolvers[3] = gsl_multiroot_fsolver_hybrids;
fsolvers[4] = 0;
fdfsolvers[0] = gsl_multiroot_fdfsolver_newton;
fdfsolvers[1] = gsl_multiroot_fdfsolver_gnewton;
fdfsolvers[2] = gsl_multiroot_fdfsolver_hybridj;
fdfsolvers[3] = gsl_multiroot_fdfsolver_hybridsj;
fdfsolvers[4] = 0;
gsl_ieee_env_setup();
f = 1.0 ;
T1 = fsolvers ;
while (*T1 != 0)
{
test_f ("Rosenbrock", &rosenbrock, rosenbrock_initpt, f, *T1);
test_f ("Roth", &roth, roth_initpt, f, *T1);
test_f ("Powell badly scaled", &powellscal, powellscal_initpt, f, *T1);
test_f ("Brown badly scaled", &brownscal, brownscal_initpt, f, *T1);
test_f ("Powell singular", &powellsing, powellsing_initpt, f, *T1);
test_f ("Wood", &wood, wood_initpt, f, *T1);
test_f ("Helical", &helical, helical_initpt, f, *T1);
test_f ("Discrete BVP", &dbv, dbv_initpt, f, *T1);
test_f ("Trig", &trig, trig_initpt, f, *T1);
T1++;
}
T2 = fdfsolvers ;
while (*T2 != 0)
{
test_fdf ("Rosenbrock", &rosenbrock, rosenbrock_initpt, f, *T2);
test_fdf ("Roth", &roth, roth_initpt, f, *T2);
test_fdf ("Powell badly scaled", &powellscal, powellscal_initpt, f, *T2);
test_fdf ("Brown badly scaled", &brownscal, brownscal_initpt, f, *T2);
test_fdf ("Powell singular", &powellsing, powellsing_initpt, f, *T2);
test_fdf ("Wood", &wood, wood_initpt, f, *T2);
test_fdf ("Helical", &helical, helical_initpt, f, *T2);
test_fdf ("Discrete BVP", &dbv, dbv_initpt, f, *T2);
test_fdf ("Trig", &trig, trig_initpt, f, *T2);
T2++;
}
exit (gsl_test_summary ());
}
