NonLinearOptimization.cpp File Reference

#include <stdio.h>
#include "main.h"
#include <unsupported/Eigen/NonLinearOptimization>
#include <Eigen/src/Core/util/DisableStupidWarnings.h>

Classes
struct	Functor< Scalar_, NX, NY >
struct	lmder_functor
struct	hybrj_functor
struct	hybrd_functor
struct	lmstr_functor
struct	lmdif_functor
struct	chwirut2_functor
struct	misra1a_functor
struct	hahn1_functor
struct	misra1d_functor
struct	lanczos1_functor
struct	rat42_functor
struct	MGH10_functor
struct	BoxBOD_functor
struct	MGH17_functor
struct	MGH09_functor
struct	Bennett5_functor
struct	thurber_functor
struct	rat43_functor
struct	eckerle4_functor

Macros
#define	LM_EVAL_COUNT_TOL   2
#define	LM_CHECK_N_ITERS(SOLVER, NFEV, NJEV)

Functions
int	fcn_chkder (const VectorXd &x, VectorXd &fvec, MatrixXd &fjac, int iflag)
void	testChkder ()
void	testLmder1 ()
void	testLmder ()
void	testHybrj1 ()
void	testHybrj ()
void	testHybrd1 ()
void	testHybrd ()
void	testLmstr1 ()
void	testLmstr ()
void	testLmdif1 ()
void	testLmdif ()
void	testNistChwirut2 (void)
void	testNistMisra1a (void)
void	testNistHahn1 (void)
void	testNistMisra1d (void)
void	testNistLanczos1 (void)
void	testNistRat42 (void)
void	testNistMGH10 (void)
void	testNistBoxBOD (void)
void	testNistMGH17 (void)
void	testNistMGH09 (void)
void	testNistBennett5 (void)
void	testNistThurber (void)
void	testNistRat43 (void)
void	testNistEckerle4 (void)
	EIGEN_DECLARE_TEST (NonLinearOptimization)

Macro Definition Documentation

LM_CHECK_N_ITERS

#define LM_CHECK_N_ITERS	(		SOLVER,
			NFEV,
			NJEV
	)

Value:

  {                                                  \
    VERIFY(SOLVER.nfev <= NFEV * LM_EVAL_COUNT_TOL); \
    VERIFY(SOLVER.njev <= NJEV * LM_EVAL_COUNT_TOL); \
  }

LM_EVAL_COUNT_TOL

#define LM_EVAL_COUNT_TOL   2

Function Documentation

EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST

(

NonLinearOptimization

)

                                          {
  // Tests using the examples provided by (c)minpack
  CALL_SUBTEST /*_1*/ (testChkder());
  CALL_SUBTEST /*_1*/ (testLmder1());
  CALL_SUBTEST /*_1*/ (testLmder());
  CALL_SUBTEST /*_2*/ (testHybrj1());
  CALL_SUBTEST /*_2*/ (testHybrj());
  CALL_SUBTEST /*_2*/ (testHybrd1());
  CALL_SUBTEST /*_2*/ (testHybrd());
  CALL_SUBTEST /*_3*/ (testLmstr1());
  CALL_SUBTEST /*_3*/ (testLmstr());
  CALL_SUBTEST /*_3*/ (testLmdif1());
  CALL_SUBTEST /*_3*/ (testLmdif());
 
  // NIST tests, level of difficulty = "Lower"
  CALL_SUBTEST /*_4*/ (testNistMisra1a());
  CALL_SUBTEST /*_4*/ (testNistChwirut2());
 
  // NIST tests, level of difficulty = "Average"
  CALL_SUBTEST /*_5*/ (testNistHahn1());
  CALL_SUBTEST /*_6*/ (testNistMisra1d());
  CALL_SUBTEST /*_7*/ (testNistMGH17());
  CALL_SUBTEST /*_8*/ (testNistLanczos1());
 
  //     // NIST tests, level of difficulty = "Higher"
  CALL_SUBTEST /*_9*/ (testNistRat42());
  //     CALL_SUBTEST/*_10*/(testNistMGH10());
  CALL_SUBTEST /*_11*/ (testNistBoxBOD());
  //     CALL_SUBTEST/*_12*/(testNistMGH09());
  CALL_SUBTEST /*_13*/ (testNistBennett5());
  CALL_SUBTEST /*_14*/ (testNistThurber());
  CALL_SUBTEST /*_15*/ (testNistRat43());
  CALL_SUBTEST /*_16*/ (testNistEckerle4());
}

References CALL_SUBTEST, testChkder(), testHybrd(), testHybrd1(), testHybrj(), testHybrj1(), testLmder(), testLmder1(), testLmdif(), testLmdif1(), testLmstr(), testLmstr1(), testNistBennett5(), testNistBoxBOD(), testNistChwirut2(), testNistEckerle4(), testNistHahn1(), testNistLanczos1(), testNistMGH17(), testNistMisra1a(), testNistMisra1d(), testNistRat42(), testNistRat43(), and testNistThurber().

fcn_chkder()

int fcn_chkder	(	const VectorXd &	x,
		VectorXd &	fvec,
		MatrixXd &	fjac,
		int	iflag
	)

                                                                             {
  /*      subroutine fcn for chkder example. */
 
  int i;
  assert(15 == fvec.size());
  assert(3 == x.size());
  double tmp1, tmp2, tmp3, tmp4;
  static const double y[15] = {1.4e-1, 1.8e-1, 2.2e-1, 2.5e-1, 2.9e-1, 3.2e-1, 3.5e-1, 3.9e-1,
                               3.7e-1, 5.8e-1, 7.3e-1, 9.6e-1, 1.34,   2.1,    4.39};
 
  if (iflag == 0) return 0;
 
  if (iflag != 2)
    for (i = 0; i < 15; i++) {
      tmp1 = i + 1;
      tmp2 = 16 - i - 1;
      tmp3 = tmp1;
      if (i >= 8) tmp3 = tmp2;
      fvec[i] = y[i] - (x[0] + tmp1 / (x[1] * tmp2 + x[2] * tmp3));
    }
  else {
    for (i = 0; i < 15; i++) {
      tmp1 = i + 1;
      tmp2 = 16 - i - 1;
 
      /* error introduced into next statement for illustration. */
      /* corrected statement should read    tmp3 = tmp1 . */
 
      tmp3 = tmp2;
      if (i >= 8) tmp3 = tmp2;
      tmp4 = (x[1] * tmp2 + x[2] * tmp3);
      tmp4 = tmp4 * tmp4;
      fjac(i, 0) = -1.;
      fjac(i, 1) = tmp1 * tmp2 / tmp4;
      fjac(i, 2) = tmp1 * tmp3 / tmp4;
    }
  }
  return 0;
}

References assert, i, plotDoE::x, and y.

Referenced by testChkder().

testChkder()

void testChkder

(

)

                  {
  const int m = 15, n = 3;
  VectorXd x(n), fvec(m), xp, fvecp(m), err;
  MatrixXd fjac(m, n);
  VectorXi ipvt;
 
  /*      the following values should be suitable for */
  /*      checking the jacobian matrix. */
  x << 9.2e-1, 1.3e-1, 5.4e-1;
 
  internal::chkder(x, fvec, fjac, xp, fvecp, 1, err);
  fcn_chkder(x, fvec, fjac, 1);
  fcn_chkder(x, fvec, fjac, 2);
  fcn_chkder(xp, fvecp, fjac, 1);
  internal::chkder(x, fvec, fjac, xp, fvecp, 2, err);
 
  fvecp -= fvec;
 
  // check those
  VectorXd fvec_ref(m), fvecp_ref(m), err_ref(m);
  fvec_ref << -1.181606, -1.429655, -1.606344, -1.745269, -1.840654, -1.921586, -1.984141, -2.022537, -2.468977,
      -2.827562, -3.473582, -4.437612, -6.047662, -9.267761, -18.91806;
  fvecp_ref << -7.724666e-09, -3.432406e-09, -2.034843e-10, 2.313685e-09, 4.331078e-09, 5.984096e-09, 7.363281e-09,
      8.53147e-09, 1.488591e-08, 2.33585e-08, 3.522012e-08, 5.301255e-08, 8.26666e-08, 1.419747e-07, 3.19899e-07;
  err_ref << 0.1141397, 0.09943516, 0.09674474, 0.09980447, 0.1073116, 0.1220445, 0.1526814, 1, 1, 1, 1, 1, 1, 1, 1;
 
  VERIFY_IS_APPROX(fvec, fvec_ref);
  VERIFY_IS_APPROX(fvecp, fvecp_ref);
  VERIFY_IS_APPROX(err, err_ref);
}

References Eigen::internal::chkder(), fcn_chkder(), m, n, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testHybrd()

void testHybrd

(

)

                 {
  const int n = 9;
  int info;
  VectorXd x;
 
  /* the following starting values provide a rough fit. */
  x.setConstant(n, -1.);
 
  // do the computation
  hybrd_functor functor;
  HybridNonLinearSolver<hybrd_functor> solver(functor);
  solver.parameters.nb_of_subdiagonals = 1;
  solver.parameters.nb_of_superdiagonals = 1;
  solver.diag.setConstant(n, 1.);
  solver.useExternalScaling = true;
  info = solver.solveNumericalDiff(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  VERIFY(solver.nfev <= 14 * LM_EVAL_COUNT_TOL);
 
  // check norm
  VERIFY_IS_APPROX(solver.fvec.blueNorm(), 1.192636e-08);
 
  // check x
  VectorXd x_ref(n);
  x_ref << -0.5706545, -0.6816283, -0.7017325, -0.7042129, -0.701369, -0.6918656, -0.665792, -0.5960342, -0.4164121;
  VERIFY_IS_APPROX(x, x_ref);
}

References EIGEN_UNUSED_VARIABLE, info, LM_EVAL_COUNT_TOL, n, solver, VERIFY, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testHybrd1()

void testHybrd1

(

)

                  {
  int n = 9, info;
  VectorXd x(n);
 
  /* the following starting values provide a rough solution. */
  x.setConstant(n, -1.);
 
  // do the computation
  hybrd_functor functor;
  HybridNonLinearSolver<hybrd_functor> solver(functor);
  info = solver.hybrd1(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  VERIFY(solver.nfev <= 20 * LM_EVAL_COUNT_TOL);
 
  // check norm
  VERIFY_IS_APPROX(solver.fvec.blueNorm(), 1.192636e-08);
 
  // check x
  VectorXd x_ref(n);
  x_ref << -0.5706545, -0.6816283, -0.7017325, -0.7042129, -0.701369, -0.6918656, -0.665792, -0.5960342, -0.4164121;
  VERIFY_IS_APPROX(x, x_ref);
}

References EIGEN_UNUSED_VARIABLE, info, LM_EVAL_COUNT_TOL, n, solver, VERIFY, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testHybrj()

void testHybrj

(

)

                 {
  const int n = 9;
  int info;
  VectorXd x(n);
 
  /* the following starting values provide a rough fit. */
  x.setConstant(n, -1.);
 
  // do the computation
  hybrj_functor functor;
  HybridNonLinearSolver<hybrj_functor> solver(functor);
  solver.diag.setConstant(n, 1.);
  solver.useExternalScaling = true;
  info = solver.solve(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(solver, 11, 1);
 
  // check norm
  VERIFY_IS_APPROX(solver.fvec.blueNorm(), 1.192636e-08);
 
  // check x
  VectorXd x_ref(n);
  x_ref << -0.5706545, -0.6816283, -0.7017325, -0.7042129, -0.701369, -0.6918656, -0.665792, -0.5960342, -0.4164121;
  VERIFY_IS_APPROX(x, x_ref);
}

References EIGEN_UNUSED_VARIABLE, info, LM_CHECK_N_ITERS, n, solver, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testHybrj1()

void testHybrj1

(

)

                  {
  const int n = 9;
  int info;
  VectorXd x(n);
 
  /* the following starting values provide a rough fit. */
  x.setConstant(n, -1.);
 
  // do the computation
  hybrj_functor functor;
  HybridNonLinearSolver<hybrj_functor> solver(functor);
  info = solver.hybrj1(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(solver, 11, 1);
 
  // check norm
  VERIFY_IS_APPROX(solver.fvec.blueNorm(), 1.192636e-08);
 
  // check x
  VectorXd x_ref(n);
  x_ref << -0.5706545, -0.6816283, -0.7017325, -0.7042129, -0.701369, -0.6918656, -0.665792, -0.5960342, -0.4164121;
  VERIFY_IS_APPROX(x, x_ref);
}

References EIGEN_UNUSED_VARIABLE, info, LM_CHECK_N_ITERS, n, solver, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testLmder()

void testLmder

(

)

                 {
  const int m = 15, n = 3;
  int info;
  double fnorm, covfac;
  VectorXd x;
 
  /* the following starting values provide a rough fit. */
  x.setConstant(n, 1.);
 
  // do the computation
  lmder_functor functor;
  LevenbergMarquardt<lmder_functor> lm(functor);
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return values
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 6, 5);
 
  // check norm
  fnorm = lm.fvec.blueNorm();
  VERIFY_IS_APPROX(fnorm, 0.09063596);
 
  // check x
  VectorXd x_ref(n);
  x_ref << 0.08241058, 1.133037, 2.343695;
  VERIFY_IS_APPROX(x, x_ref);
 
  // check covariance
  covfac = fnorm * fnorm / (m - n);
  internal::covar(lm.fjac, lm.permutation.indices());  // TODO : move this as a function of lm
 
  MatrixXd cov_ref(n, n);
  cov_ref << 0.0001531202, 0.002869941, -0.002656662, 0.002869941, 0.09480935, -0.09098995, -0.002656662, -0.09098995,
      0.08778727;
 
  //  std::cout << fjac*covfac << std::endl;
 
  MatrixXd cov;
  cov = covfac * lm.fjac.topLeftCorner<n, n>();
  VERIFY_IS_APPROX(cov, cov_ref);
  // TODO: why isn't this allowed ? :
  // VERIFY_IS_APPROX( covfac*fjac.topLeftCorner<n,n>() , cov_ref);
}

References Eigen::internal::covar(), EIGEN_UNUSED_VARIABLE, Eigen::LevenbergMarquardt< FunctorType_ >::fjac, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, Eigen::PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_ >::indices(), info, LM_CHECK_N_ITERS, m, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::permutation, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testLmder1()

void testLmder1

(

)

                  {
  int n = 3, info;
 
  VectorXd x;
 
  /* the following starting values provide a rough fit. */
  x.setConstant(n, 1.);
 
  // do the computation
  lmder_functor functor;
  LevenbergMarquardt<lmder_functor> lm(functor);
  info = lm.lmder1(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 6, 5);
 
  // check norm
  VERIFY_IS_APPROX(lm.fvec.blueNorm(), 0.09063596);
 
  // check x
  VectorXd x_ref(n);
  x_ref << 0.08241058, 1.133037, 2.343695;
  VERIFY_IS_APPROX(x, x_ref);
}

References EIGEN_UNUSED_VARIABLE, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::lmder1(), n, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testLmdif()

void testLmdif

(

)

                 {
  const int m = 15, n = 3;
  int info;
  double fnorm, covfac;
  VectorXd x(n);
 
  /* the following starting values provide a rough fit. */
  x.setConstant(n, 1.);
 
  // do the computation
  lmdif_functor functor;
  NumericalDiff<lmdif_functor> numDiff(functor);
  LevenbergMarquardt<NumericalDiff<lmdif_functor> > lm(numDiff);
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return values
  // VERIFY_IS_EQUAL(info, 1);
  VERIFY(lm.nfev <= 26 * LM_EVAL_COUNT_TOL);
 
  // check norm
  fnorm = lm.fvec.blueNorm();
  VERIFY_IS_APPROX(fnorm, 0.09063596);
 
  // check x
  VectorXd x_ref(n);
  x_ref << 0.08241058, 1.133037, 2.343695;
  VERIFY_IS_APPROX(x, x_ref);
 
  // check covariance
  covfac = fnorm * fnorm / (m - n);
  internal::covar(lm.fjac, lm.permutation.indices());  // TODO : move this as a function of lm
 
  MatrixXd cov_ref(n, n);
  cov_ref << 0.0001531202, 0.002869942, -0.002656662, 0.002869942, 0.09480937, -0.09098997, -0.002656662, -0.09098997,
      0.08778729;
 
  //  std::cout << fjac*covfac << std::endl;
 
  MatrixXd cov;
  cov = covfac * lm.fjac.topLeftCorner<n, n>();
  VERIFY_IS_APPROX(cov, cov_ref);
  // TODO: why isn't this allowed ? :
  // VERIFY_IS_APPROX( covfac*fjac.topLeftCorner<n,n>() , cov_ref);
}

References Eigen::internal::covar(), EIGEN_UNUSED_VARIABLE, Eigen::LevenbergMarquardt< FunctorType_ >::fjac, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, Eigen::PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_ >::indices(), info, LM_EVAL_COUNT_TOL, m, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::nfev, Eigen::LevenbergMarquardt< FunctorType_ >::permutation, VERIFY, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testLmdif1()

void testLmdif1

(

)

                  {
  const int n = 3;
  int info;
 
  VectorXd x(n), fvec(15);
 
  /* the following starting values provide a rough fit. */
  x.setConstant(n, 1.);
 
  // do the computation
  lmdif_functor functor;
  DenseIndex nfev = -1;  // initialize to avoid maybe-uninitialized warning
  info = LevenbergMarquardt<lmdif_functor>::lmdif1(functor, x, &nfev);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  VERIFY(nfev <= 26 * LM_EVAL_COUNT_TOL);
 
  // check norm
  functor(x, fvec);
  VERIFY_IS_APPROX(fvec.blueNorm(), 0.09063596);
 
  // check x
  VectorXd x_ref(n);
  x_ref << 0.0824106, 1.1330366, 2.3436947;
  VERIFY_IS_APPROX(x, x_ref);
}

References EIGEN_UNUSED_VARIABLE, info, LM_EVAL_COUNT_TOL, n, VERIFY, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testLmstr()

void testLmstr

(

)

                 {
  const int n = 3;
  int info;
  double fnorm;
  VectorXd x(n);
 
  /* the following starting values provide a rough fit. */
  x.setConstant(n, 1.);
 
  // do the computation
  lmstr_functor functor;
  LevenbergMarquardt<lmstr_functor> lm(functor);
  info = lm.minimizeOptimumStorage(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return values
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 6, 5);
 
  // check norm
  fnorm = lm.fvec.blueNorm();
  VERIFY_IS_APPROX(fnorm, 0.09063596);
 
  // check x
  VectorXd x_ref(n);
  x_ref << 0.08241058, 1.133037, 2.343695;
  VERIFY_IS_APPROX(x, x_ref);
}

References EIGEN_UNUSED_VARIABLE, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::minimizeOptimumStorage(), n, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testLmstr1()

void testLmstr1

(

)

                  {
  const int n = 3;
  int info;
 
  VectorXd x(n);
 
  /* the following starting values provide a rough fit. */
  x.setConstant(n, 1.);
 
  // do the computation
  lmstr_functor functor;
  LevenbergMarquardt<lmstr_functor> lm(functor);
  info = lm.lmstr1(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 6, 5);
 
  // check norm
  VERIFY_IS_APPROX(lm.fvec.blueNorm(), 0.09063596);
 
  // check x
  VectorXd x_ref(n);
  x_ref << 0.08241058, 1.133037, 2.343695;
  VERIFY_IS_APPROX(x, x_ref);
}

References EIGEN_UNUSED_VARIABLE, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::lmstr1(), n, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testNistBennett5()

void testNistBennett5

(

void

)

                            {
  const int n = 3;
  int info;
 
  VectorXd x(n);
 
  /*
   * First try
   */
  x << -2000., 50., 0.8;
  // do the computation
  Bennett5_functor functor;
  LevenbergMarquardt<Bennett5_functor> lm(functor);
  lm.parameters.maxfev = 1000;
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 758, 744);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.2404744073E-04);
  // check x
  VERIFY_IS_APPROX(x[0], -2.5235058043E+03);
  VERIFY_IS_APPROX(x[1], 4.6736564644E+01);
  VERIFY_IS_APPROX(x[2], 9.3218483193E-01);
  /*
   * Second try
   */
  x << -1500., 45., 0.85;
  // do the computation
  lm.resetParameters();
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 203, 192);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.2404744073E-04);
  // check x
  VERIFY_IS_APPROX(x[0], -2523.3007865);  // should be -2.5235058043E+03
  VERIFY_IS_APPROX(x[1], 46.735705771);   // should be 4.6736564644E+01);
  VERIFY_IS_APPROX(x[2], 0.93219881891);  // should be 9.3218483193E-01);
}

References EIGEN_UNUSED_VARIABLE, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::Parameters::maxfev, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::parameters, Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testNistBoxBOD()

void testNistBoxBOD

(

void

)

                          {
  const int n = 2;
  int info;
 
  VectorXd x(n);
 
  /*
   * First try
   */
  x << 1., 1.;
  // do the computation
  BoxBOD_functor functor;
  LevenbergMarquardt<BoxBOD_functor> lm(functor);
  lm.parameters.ftol = 1.E6 * NumTraits<double>::epsilon();
  lm.parameters.xtol = 1.E6 * NumTraits<double>::epsilon();
  lm.parameters.factor = 10.;
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 31, 25);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.1680088766E+03);
  // check x
  VERIFY_IS_APPROX(x[0], 2.1380940889E+02);
  VERIFY_IS_APPROX(x[1], 5.4723748542E-01);
 
  /*
   * Second try
   */
  x << 100., 0.75;
  // do the computation
  lm.resetParameters();
  lm.parameters.ftol = NumTraits<double>::epsilon();
  lm.parameters.xtol = NumTraits<double>::epsilon();
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 20, 14);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.1680088766E+03);
  // check x
  VERIFY_IS_APPROX(x[0], 2.1380940889E+02);
  VERIFY_IS_APPROX(x[1], 5.4723748542E-01);
}

References EIGEN_UNUSED_VARIABLE, oomph::SarahBL::epsilon, Eigen::LevenbergMarquardt< FunctorType_ >::Parameters::factor, Eigen::LevenbergMarquardt< FunctorType_ >::Parameters::ftol, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::parameters, Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), VERIFY_IS_APPROX, plotDoE::x, and Eigen::LevenbergMarquardt< FunctorType_ >::Parameters::xtol.

Referenced by EIGEN_DECLARE_TEST().

testNistChwirut2()

void testNistChwirut2

(

void

)

                            {
  const int n = 3;
  int info;
 
  VectorXd x(n);
 
  /*
   * First try
   */
  x << 0.1, 0.01, 0.02;
  // do the computation
  chwirut2_functor functor;
  LevenbergMarquardt<chwirut2_functor> lm(functor);
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 10, 8);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.1304802941E+02);
  // check x
  VERIFY_IS_APPROX(x[0], 1.6657666537E-01);
  VERIFY_IS_APPROX(x[1], 5.1653291286E-03);
  VERIFY_IS_APPROX(x[2], 1.2150007096E-02);
 
  /*
   * Second try
   */
  x << 0.15, 0.008, 0.010;
  // do the computation
  lm.resetParameters();
  lm.parameters.ftol = 1.E6 * NumTraits<double>::epsilon();
  lm.parameters.xtol = 1.E6 * NumTraits<double>::epsilon();
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 7, 6);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.1304802941E+02);
  // check x
  VERIFY_IS_APPROX(x[0], 1.6657666537E-01);
  VERIFY_IS_APPROX(x[1], 5.1653291286E-03);
  VERIFY_IS_APPROX(x[2], 1.2150007096E-02);
}

References EIGEN_UNUSED_VARIABLE, oomph::SarahBL::epsilon, Eigen::LevenbergMarquardt< FunctorType_ >::Parameters::ftol, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::parameters, Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), VERIFY_IS_APPROX, plotDoE::x, and Eigen::LevenbergMarquardt< FunctorType_ >::Parameters::xtol.

Referenced by EIGEN_DECLARE_TEST().

testNistEckerle4()

void testNistEckerle4

(

void

)

                            {
  const int n = 3;
  int info;
 
  VectorXd x(n);
 
  /*
   * First try
   */
  x << 1., 10., 500.;
  // do the computation
  eckerle4_functor functor;
  LevenbergMarquardt<eckerle4_functor> lm(functor);
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 18, 15);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.4635887487E-03);
  // check x
  VERIFY_IS_APPROX(x[0], 1.5543827178);
  VERIFY_IS_APPROX(x[1], 4.0888321754);
  VERIFY_IS_APPROX(x[2], 4.5154121844E+02);
 
  /*
   * Second try
   */
  x << 1.5, 5., 450.;
  // do the computation
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 7, 6);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.4635887487E-03);
  // check x
  VERIFY_IS_APPROX(x[0], 1.5543827178);
  VERIFY_IS_APPROX(x[1], 4.0888321754);
  VERIFY_IS_APPROX(x[2], 4.5154121844E+02);
}

References EIGEN_UNUSED_VARIABLE, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testNistHahn1()

void testNistHahn1

(

void

)

                         {
  const int n = 7;
  int info;
 
  VectorXd x(n);
 
  /*
   * First try
   */
  x << 10., -1., .05, -.00001, -.05, .001, -.000001;
  // do the computation
  hahn1_functor functor;
  LevenbergMarquardt<hahn1_functor> lm(functor);
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 11, 10);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.5324382854E+00);
  // check x
  VERIFY_IS_APPROX(x[0], 1.0776351733E+00);
  VERIFY_IS_APPROX(x[1], -1.2269296921E-01);
  VERIFY_IS_APPROX(x[2], 4.0863750610E-03);
  VERIFY_IS_APPROX(x[3], -1.426264e-06);  // shoulde be : -1.4262662514E-06
  VERIFY_IS_APPROX(x[4], -5.7609940901E-03);
  VERIFY_IS_APPROX(x[5], 2.4053735503E-04);
  VERIFY_IS_APPROX(x[6], -1.2314450199E-07);
 
  /*
   * Second try
   */
  x << .1, -.1, .005, -.000001, -.005, .0001, -.0000001;
  // do the computation
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 11, 10);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.5324382854E+00);
  // check x
  VERIFY_IS_APPROX(x[0], 1.077640);       // should be :  1.0776351733E+00
  VERIFY_IS_APPROX(x[1], -0.1226933);     // should be : -1.2269296921E-01
  VERIFY_IS_APPROX(x[2], 0.004086383);    // should be : 4.0863750610E-03
  VERIFY_IS_APPROX(x[3], -1.426277e-06);  // shoulde be : -1.4262662514E-06
  VERIFY_IS_APPROX(x[4], -5.7609940901E-03);
  VERIFY_IS_APPROX(x[5], 0.00024053772);  // should be : 2.4053735503E-04
  VERIFY_IS_APPROX(x[6], -1.231450e-07);  // should be : -1.2314450199E-07
}

References EIGEN_UNUSED_VARIABLE, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testNistLanczos1()

void testNistLanczos1

(

void

)

                            {
  const int n = 6;
  int info;
 
  VectorXd x(n);
 
  /*
   * First try
   */
  x << 1.2, 0.3, 5.6, 5.5, 6.5, 7.6;
  // do the computation
  lanczos1_functor functor;
  LevenbergMarquardt<lanczos1_functor> lm(functor);
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 2);
  LM_CHECK_N_ITERS(lm, 79, 72);
  // check norm^2
  // std::cout.precision(30);
  // std::cout << lm.fvec.squaredNorm() << "\n";
  VERIFY(lm.fvec.squaredNorm() <= 1.44E-25);
  // check x
  VERIFY_IS_APPROX(x[0], 9.5100000027E-02);
  VERIFY_IS_APPROX(x[1], 1.0000000001E+00);
  VERIFY_IS_APPROX(x[2], 8.6070000013E-01);
  VERIFY_IS_APPROX(x[3], 3.0000000002E+00);
  VERIFY_IS_APPROX(x[4], 1.5575999998E+00);
  VERIFY_IS_APPROX(x[5], 5.0000000001E+00);
 
  /*
   * Second try
   */
  x << 0.5, 0.7, 3.6, 4.2, 4., 6.3;
  // do the computation
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 2);
  LM_CHECK_N_ITERS(lm, 9, 8);
  // check norm^2
  VERIFY(lm.fvec.squaredNorm() <= 1.44E-25);
  // check x
  VERIFY_IS_APPROX(x[0], 9.5100000027E-02);
  VERIFY_IS_APPROX(x[1], 1.0000000001E+00);
  VERIFY_IS_APPROX(x[2], 8.6070000013E-01);
  VERIFY_IS_APPROX(x[3], 3.0000000002E+00);
  VERIFY_IS_APPROX(x[4], 1.5575999998E+00);
  VERIFY_IS_APPROX(x[5], 5.0000000001E+00);
}

References EIGEN_UNUSED_VARIABLE, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, VERIFY, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testNistMGH09()

void testNistMGH09

(

void

)

                         {
  const int n = 4;
  int info;
 
  VectorXd x(n);
 
  /*
   * First try
   */
  x << 25., 39, 41.5, 39.;
  // do the computation
  MGH09_functor functor;
  LevenbergMarquardt<MGH09_functor> lm(functor);
  lm.parameters.maxfev = 1000;
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 490, 376);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 3.0750560385E-04);
  // check x
  VERIFY_IS_APPROX(x[0], 0.1928077089);   // should be 1.9280693458E-01
  VERIFY_IS_APPROX(x[1], 0.19126423573);  // should be 1.9128232873E-01
  VERIFY_IS_APPROX(x[2], 0.12305309914);  // should be 1.2305650693E-01
  VERIFY_IS_APPROX(x[3], 0.13605395375);  // should be 1.3606233068E-01
 
  /*
   * Second try
   */
  x << 0.25, 0.39, 0.415, 0.39;
  // do the computation
  lm.resetParameters();
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 18, 16);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 3.0750560385E-04);
  // check x
  VERIFY_IS_APPROX(x[0], 0.19280781);  // should be 1.9280693458E-01
  VERIFY_IS_APPROX(x[1], 0.19126265);  // should be 1.9128232873E-01
  VERIFY_IS_APPROX(x[2], 0.12305280);  // should be 1.2305650693E-01
  VERIFY_IS_APPROX(x[3], 0.13605322);  // should be 1.3606233068E-01
}

References EIGEN_UNUSED_VARIABLE, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::Parameters::maxfev, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::parameters, Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), VERIFY_IS_APPROX, and plotDoE::x.

testNistMGH10()

void testNistMGH10

(

void

)

                         {
  const int n = 3;
  int info;
 
  VectorXd x(n);
 
  /*
   * First try
   */
  x << 2., 400000., 25000.;
  // do the computation
  MGH10_functor functor;
  LevenbergMarquardt<MGH10_functor> lm(functor);
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 2);
  LM_CHECK_N_ITERS(lm, 284, 249);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.7945855171E+01);
  // check x
  VERIFY_IS_APPROX(x[0], 5.6096364710E-03);
  VERIFY_IS_APPROX(x[1], 6.1813463463E+03);
  VERIFY_IS_APPROX(x[2], 3.4522363462E+02);
 
  /*
   * Second try
   */
  x << 0.02, 4000., 250.;
  // do the computation
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 3);
  LM_CHECK_N_ITERS(lm, 126, 116);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.7945855171E+01);
  // check x
  VERIFY_IS_APPROX(x[0], 5.6096364710E-03);
  VERIFY_IS_APPROX(x[1], 6.1813463463E+03);
  VERIFY_IS_APPROX(x[2], 3.4522363462E+02);
}

References EIGEN_UNUSED_VARIABLE, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, VERIFY_IS_APPROX, and plotDoE::x.

testNistMGH17()

void testNistMGH17

(

void

)

                         {
  const int n = 5;
  int info;
 
  VectorXd x(n);
 
  /*
   * First try
   */
  x << 50., 150., -100., 1., 2.;
  // do the computation
  MGH17_functor functor;
  LevenbergMarquardt<MGH17_functor> lm(functor);
  lm.parameters.ftol = NumTraits<double>::epsilon();
  lm.parameters.xtol = NumTraits<double>::epsilon();
  lm.parameters.maxfev = 1000;
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.4648946975E-05);
  // check x
  VERIFY_IS_APPROX(x[0], 3.7541005211E-01);
  VERIFY_IS_APPROX(x[1], 1.9358469127E+00);
  VERIFY_IS_APPROX(x[2], -1.4646871366E+00);
  VERIFY_IS_APPROX(x[3], 1.2867534640E-02);
  VERIFY_IS_APPROX(x[4], 2.2122699662E-02);
 
  // check return value
  // VERIFY_IS_EQUAL(info, 2);
  LM_CHECK_N_ITERS(lm, 602, 545);
 
  /*
   * Second try
   */
  x << 0.5, 1.5, -1, 0.01, 0.02;
  // do the computation
  lm.resetParameters();
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 18, 15);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.4648946975E-05);
  // check x
  VERIFY_IS_APPROX(x[0], 3.7541005211E-01);
  VERIFY_IS_APPROX(x[1], 1.9358469127E+00);
  VERIFY_IS_APPROX(x[2], -1.4646871366E+00);
  VERIFY_IS_APPROX(x[3], 1.2867534640E-02);
  VERIFY_IS_APPROX(x[4], 2.2122699662E-02);
}

References EIGEN_UNUSED_VARIABLE, oomph::SarahBL::epsilon, Eigen::LevenbergMarquardt< FunctorType_ >::Parameters::ftol, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::Parameters::maxfev, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::parameters, Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), VERIFY_IS_APPROX, plotDoE::x, and Eigen::LevenbergMarquardt< FunctorType_ >::Parameters::xtol.

Referenced by EIGEN_DECLARE_TEST().

testNistMisra1a()

void testNistMisra1a

(

void

)

                           {
  const int n = 2;
  int info;
 
  VectorXd x(n);
 
  /*
   * First try
   */
  x << 500., 0.0001;
  // do the computation
  misra1a_functor functor;
  LevenbergMarquardt<misra1a_functor> lm(functor);
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 19, 15);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.2455138894E-01);
  // check x
  VERIFY_IS_APPROX(x[0], 2.3894212918E+02);
  VERIFY_IS_APPROX(x[1], 5.5015643181E-04);
 
  /*
   * Second try
   */
  x << 250., 0.0005;
  // do the computation
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 5, 4);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.2455138894E-01);
  // check x
  VERIFY_IS_APPROX(x[0], 2.3894212918E+02);
  VERIFY_IS_APPROX(x[1], 5.5015643181E-04);
}

References EIGEN_UNUSED_VARIABLE, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testNistMisra1d()

void testNistMisra1d

(

void

)

                           {
  const int n = 2;
  int info;
 
  VectorXd x(n);
 
  /*
   * First try
   */
  x << 500., 0.0001;
  // do the computation
  misra1d_functor functor;
  LevenbergMarquardt<misra1d_functor> lm(functor);
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 3);
  LM_CHECK_N_ITERS(lm, 9, 7);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.6419295283E-02);
  // check x
  VERIFY_IS_APPROX(x[0], 4.3736970754E+02);
  VERIFY_IS_APPROX(x[1], 3.0227324449E-04);
 
  /*
   * Second try
   */
  x << 450., 0.0003;
  // do the computation
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 4, 3);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.6419295283E-02);
  // check x
  VERIFY_IS_APPROX(x[0], 4.3736970754E+02);
  VERIFY_IS_APPROX(x[1], 3.0227324449E-04);
}

References EIGEN_UNUSED_VARIABLE, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testNistRat42()

void testNistRat42

(

void

)

                         {
  const int n = 3;
  int info;
 
  VectorXd x(n);
 
  /*
   * First try
   */
  x << 100., 1., 0.1;
  // do the computation
  rat42_functor functor;
  LevenbergMarquardt<rat42_functor> lm(functor);
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 10, 8);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.0565229338E+00);
  // check x
  VERIFY_IS_APPROX(x[0], 7.2462237576E+01);
  VERIFY_IS_APPROX(x[1], 2.6180768402E+00);
  VERIFY_IS_APPROX(x[2], 6.7359200066E-02);
 
  /*
   * Second try
   */
  x << 75., 2.5, 0.07;
  // do the computation
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 6, 5);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.0565229338E+00);
  // check x
  VERIFY_IS_APPROX(x[0], 7.2462237576E+01);
  VERIFY_IS_APPROX(x[1], 2.6180768402E+00);
  VERIFY_IS_APPROX(x[2], 6.7359200066E-02);
}

References EIGEN_UNUSED_VARIABLE, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testNistRat43()

void testNistRat43

(

void

)

                         {
  const int n = 4;
  int info;
 
  VectorXd x(n);
 
  /*
   * First try
   */
  x << 100., 10., 1., 1.;
  // do the computation
  rat43_functor functor;
  LevenbergMarquardt<rat43_functor> lm(functor);
  lm.parameters.ftol = 1.E6 * NumTraits<double>::epsilon();
  lm.parameters.xtol = 1.E6 * NumTraits<double>::epsilon();
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 27, 20);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.7864049080E+03);
  // check x
  VERIFY_IS_APPROX(x[0], 6.9964151270E+02);
  VERIFY_IS_APPROX(x[1], 5.2771253025E+00);
  VERIFY_IS_APPROX(x[2], 7.5962938329E-01);
  VERIFY_IS_APPROX(x[3], 1.2792483859E+00);
 
  /*
   * Second try
   */
  x << 700., 5., 0.75, 1.3;
  // do the computation
  lm.resetParameters();
  lm.parameters.ftol = 1.E5 * NumTraits<double>::epsilon();
  lm.parameters.xtol = 1.E5 * NumTraits<double>::epsilon();
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 9, 8);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.7864049080E+03);
  // check x
  VERIFY_IS_APPROX(x[0], 6.9964151270E+02);
  VERIFY_IS_APPROX(x[1], 5.2771253025E+00);
  VERIFY_IS_APPROX(x[2], 7.5962938329E-01);
  VERIFY_IS_APPROX(x[3], 1.2792483859E+00);
}

References EIGEN_UNUSED_VARIABLE, oomph::SarahBL::epsilon, Eigen::LevenbergMarquardt< FunctorType_ >::Parameters::ftol, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::parameters, Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), VERIFY_IS_APPROX, plotDoE::x, and Eigen::LevenbergMarquardt< FunctorType_ >::Parameters::xtol.

Referenced by EIGEN_DECLARE_TEST().

testNistThurber()

void testNistThurber

(

void

)

                           {
  const int n = 7;
  int info;
 
  VectorXd x(n);
 
  /*
   * First try
   */
  x << 1000, 1000, 400, 40, 0.7, 0.3, 0.0;
  // do the computation
  thurber_functor functor;
  LevenbergMarquardt<thurber_functor> lm(functor);
  lm.parameters.ftol = 1.E4 * NumTraits<double>::epsilon();
  lm.parameters.xtol = 1.E4 * NumTraits<double>::epsilon();
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 39, 36);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.6427082397E+03);
  // check x
  VERIFY_IS_APPROX(x[0], 1.2881396800E+03);
  VERIFY_IS_APPROX(x[1], 1.4910792535E+03);
  VERIFY_IS_APPROX(x[2], 5.8323836877E+02);
  VERIFY_IS_APPROX(x[3], 7.5416644291E+01);
  VERIFY_IS_APPROX(x[4], 9.6629502864E-01);
  VERIFY_IS_APPROX(x[5], 3.9797285797E-01);
  VERIFY_IS_APPROX(x[6], 4.9727297349E-02);
 
  /*
   * Second try
   */
  x << 1300, 1500, 500, 75, 1, 0.4, 0.05;
  // do the computation
  lm.resetParameters();
  lm.parameters.ftol = 1.E4 * NumTraits<double>::epsilon();
  lm.parameters.xtol = 1.E4 * NumTraits<double>::epsilon();
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  LM_CHECK_N_ITERS(lm, 29, 28);
  // check norm^2
  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.6427082397E+03);
  // check x
  VERIFY_IS_APPROX(x[0], 1.2881396800E+03);
  VERIFY_IS_APPROX(x[1], 1.4910792535E+03);
  VERIFY_IS_APPROX(x[2], 5.8323836877E+02);
  VERIFY_IS_APPROX(x[3], 7.5416644291E+01);
  VERIFY_IS_APPROX(x[4], 9.6629502864E-01);
  VERIFY_IS_APPROX(x[5], 3.9797285797E-01);
  VERIFY_IS_APPROX(x[6], 4.9727297349E-02);
}

References EIGEN_UNUSED_VARIABLE, oomph::SarahBL::epsilon, Eigen::LevenbergMarquardt< FunctorType_ >::Parameters::ftol, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_CHECK_N_ITERS, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::parameters, Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), VERIFY_IS_APPROX, plotDoE::x, and Eigen::LevenbergMarquardt< FunctorType_ >::Parameters::xtol.

Referenced by EIGEN_DECLARE_TEST().