levenberg_marquardt.cpp File Reference

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

Classes
struct	lmder_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

Functions
void	testLmder1 ()
void	testLmder ()
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 (levenberg_marquardt)

Macro Definition Documentation

LM_EVAL_COUNT_TOL

#define LM_EVAL_COUNT_TOL   2

Function Documentation

EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST

(

levenberg_marquardt

)

                                        {
  // Tests using the examples provided by (c)minpack
  CALL_SUBTEST(testLmder1());
  CALL_SUBTEST(testLmder());
  CALL_SUBTEST(testLmdif1());
  //     CALL_SUBTEST(testLmstr1());
  //     CALL_SUBTEST(testLmstr());
  CALL_SUBTEST(testLmdif());
 
  // NIST tests, level of difficulty = "Lower"
  CALL_SUBTEST(testNistMisra1a());
  CALL_SUBTEST(testNistChwirut2());
 
  // NIST tests, level of difficulty = "Average"
  CALL_SUBTEST(testNistHahn1());
  CALL_SUBTEST(testNistMisra1d());
  CALL_SUBTEST(testNistMGH17());
  CALL_SUBTEST(testNistLanczos1());
 
  //     // NIST tests, level of difficulty = "Higher"
  CALL_SUBTEST(testNistRat42());
  CALL_SUBTEST(testNistMGH10());
  CALL_SUBTEST(testNistBoxBOD());
  //     CALL_SUBTEST(testNistMGH09());
  CALL_SUBTEST(testNistBennett5());
  CALL_SUBTEST(testNistThurber());
  CALL_SUBTEST(testNistRat43());
  CALL_SUBTEST(testNistEckerle4());
}

References CALL_SUBTEST, testLmder(), testLmder1(), testLmdif(), testLmdif1(), testNistBennett5(), testNistBoxBOD(), testNistChwirut2(), testNistEckerle4(), testNistHahn1(), testNistLanczos1(), testNistMGH10(), testNistMGH17(), testNistMisra1a(), testNistMisra1d(), testNistRat42(), testNistRat43(), and testNistThurber().

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);
  // VERIFY_IS_EQUAL(lm.nfev(), 6);
  // VERIFY_IS_EQUAL(lm.njev(), 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.matrixR(), 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.matrixR().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_ >::fvec, Eigen::PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_ >::indices(), info, m, Eigen::LevenbergMarquardt< FunctorType_ >::matrixR(), 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);
  // VERIFY_IS_EQUAL(lm.nfev(), 6);
  // VERIFY_IS_EQUAL(lm.njev(), 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, 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_IS_EQUAL(lm.nfev(), 26);
 
  // 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.matrixR(), 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.matrixR().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_ >::fvec, Eigen::PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_ >::indices(), info, m, Eigen::LevenbergMarquardt< FunctorType_ >::matrixR(), Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::permutation, 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;
  info = LevenbergMarquardt<lmdif_functor>::lmdif1(functor, x, &nfev);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  //   VERIFY_IS_EQUAL(nfev, 26);
 
  // 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, 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.setMaxfev(1000);
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  // VERIFY_IS_EQUAL(lm.nfev(), 758);
  // VERIFY_IS_EQUAL(lm.njev(), 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);
  // VERIFY_IS_EQUAL(lm.nfev(), 203);
  // VERIFY_IS_EQUAL(lm.njev(), 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, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), Eigen::LevenbergMarquardt< FunctorType_ >::setMaxfev(), 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.setFtol(1.E6 * NumTraits<double>::epsilon());
  lm.setXtol(1.E6 * NumTraits<double>::epsilon());
  lm.setFactor(10);
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // 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);
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  // VERIFY(lm.nfev() < 31); // 31
  // VERIFY(lm.njev() < 25); // 25
 
  /*
   * Second try
   */
  x << 100., 0.75;
  // do the computation
  lm.resetParameters();
  lm.setFtol(NumTraits<double>::epsilon());
  lm.setXtol(NumTraits<double>::epsilon());
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  // ++g_test_level;
  // VERIFY_IS_EQUAL(lm.nfev(), 16 );
  // VERIFY_IS_EQUAL(lm.njev(), 15 );
  // --g_test_level;
  VERIFY(lm.nfev() < 16 * LM_EVAL_COUNT_TOL);
  VERIFY(lm.njev() < 15 * LM_EVAL_COUNT_TOL);
  // 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, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, LM_EVAL_COUNT_TOL, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::nfev, Eigen::LevenbergMarquardt< FunctorType_ >::njev, Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), Eigen::LevenbergMarquardt< FunctorType_ >::setFactor(), Eigen::LevenbergMarquardt< FunctorType_ >::setFtol(), Eigen::LevenbergMarquardt< FunctorType_ >::setXtol(), VERIFY, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testNistChwirut2()

void testNistChwirut2

(

void

)

                            {
  const int n = 3;
  LevenbergMarquardtSpace::Status 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);
  //   VERIFY_IS_EQUAL(lm.nfev(), 10);
  // VERIFY_IS_EQUAL(lm.njev(), 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.setFtol(1.E6 * NumTraits<double>::epsilon());
  lm.setXtol(1.E6 * NumTraits<double>::epsilon());
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  //   VERIFY_IS_EQUAL(lm.nfev(), 7);
  // VERIFY_IS_EQUAL(lm.njev(), 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, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), Eigen::LevenbergMarquardt< FunctorType_ >::setFtol(), Eigen::LevenbergMarquardt< FunctorType_ >::setXtol(), VERIFY_IS_APPROX, and plotDoE::x.

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);
  // VERIFY_IS_EQUAL(lm.nfev(), 18);
  // VERIFY_IS_EQUAL(lm.njev(), 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);
  // VERIFY_IS_EQUAL(lm.nfev(), 7);
  // VERIFY_IS_EQUAL(lm.njev(), 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, 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);
  // VERIFY_IS_EQUAL(lm.nfev(), 11);
  // VERIFY_IS_EQUAL(lm.njev(), 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);
  //   VERIFY_IS_EQUAL(lm.nfev(), 11);
  // VERIFY_IS_EQUAL(lm.njev(), 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, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testNistLanczos1()

void testNistLanczos1

(

void

)

                            {
  const int n = 6;
  LevenbergMarquardtSpace::Status 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, LevenbergMarquardtSpace::RelativeErrorTooSmall);
  // VERIFY_IS_EQUAL(lm.nfev(), 79);
  // VERIFY_IS_EQUAL(lm.njev(), 72);
  // 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);
 
  /*
   * 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, LevenbergMarquardtSpace::RelativeErrorTooSmall);
  // VERIFY_IS_EQUAL(lm.nfev(), 9);
  // VERIFY_IS_EQUAL(lm.njev(), 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, 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.setMaxfev(1000);
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // 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
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  // VERIFY(lm.nfev() < 510 ); // 490
  // VERIFY(lm.njev() < 400 ); // 376
 
  /*
   * 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);
  // VERIFY_IS_EQUAL(lm.nfev(), 18);
  // VERIFY_IS_EQUAL(lm.njev(), 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, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), Eigen::LevenbergMarquardt< FunctorType_ >::setMaxfev(), VERIFY_IS_APPROX, and plotDoE::x.

testNistMGH10()

void testNistMGH10

(

void

)

                         {
  const int n = 3;
  LevenbergMarquardtSpace::Status 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)
  // ++g_test_level;
  // VERIFY_IS_EQUAL(info, LevenbergMarquardtSpace::RelativeReductionTooSmall);
  // --g_test_level;
  // was: VERIFY_IS_EQUAL(info, 1);
 
  // 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);
 
  // check return value
 
  // ++g_test_level;
  // VERIFY_IS_EQUAL(lm.nfev(), 284 );
  // VERIFY_IS_EQUAL(lm.njev(), 249 );
  // --g_test_level;
  VERIFY(lm.nfev() < 284 * LM_EVAL_COUNT_TOL);
  VERIFY(lm.njev() < 249 * LM_EVAL_COUNT_TOL);
 
  /*
   * Second try
   */
  x << 0.02, 4000., 250.;
  // do the computation
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
  // ++g_test_level;
  // VERIFY_IS_EQUAL(info, LevenbergMarquardtSpace::RelativeReductionTooSmall);
  // // was: VERIFY_IS_EQUAL(info, 1);
  // --g_test_level;
 
  // 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);
 
  // check return value
  // ++g_test_level;
  // VERIFY_IS_EQUAL(lm.nfev(), 126);
  // VERIFY_IS_EQUAL(lm.njev(), 116);
  // --g_test_level;
  VERIFY(lm.nfev() < 126 * LM_EVAL_COUNT_TOL);
  VERIFY(lm.njev() < 116 * LM_EVAL_COUNT_TOL);
}

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

Referenced by EIGEN_DECLARE_TEST().

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.setFtol(NumTraits<double>::epsilon());
  lm.setXtol(NumTraits<double>::epsilon());
  lm.setMaxfev(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);  //FIXME Use (lm.info() == Success)
  // VERIFY(lm.nfev() < 700 ); // 602
  // VERIFY(lm.njev() < 600 ); // 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);
  // VERIFY_IS_EQUAL(lm.nfev(), 18);
  // VERIFY_IS_EQUAL(lm.njev(), 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, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), Eigen::LevenbergMarquardt< FunctorType_ >::setFtol(), Eigen::LevenbergMarquardt< FunctorType_ >::setMaxfev(), Eigen::LevenbergMarquardt< FunctorType_ >::setXtol(), VERIFY_IS_APPROX, and plotDoE::x.

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);
  // VERIFY_IS_EQUAL(lm.nfev(), 19);
  // VERIFY_IS_EQUAL(lm.njev(), 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);
  // VERIFY_IS_EQUAL(lm.nfev(), 5);
  // VERIFY_IS_EQUAL(lm.njev(), 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, 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, 1);
  // VERIFY_IS_EQUAL(lm.nfev(), 9);
  // VERIFY_IS_EQUAL(lm.njev(), 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);
  // VERIFY_IS_EQUAL(lm.nfev(), 4);
  // VERIFY_IS_EQUAL(lm.njev(), 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, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().

testNistRat42()

void testNistRat42

(

void

)

                         {
  const int n = 3;
  LevenbergMarquardtSpace::Status 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, LevenbergMarquardtSpace::RelativeReductionTooSmall);
  // VERIFY_IS_EQUAL(lm.nfev(), 10);
  // VERIFY_IS_EQUAL(lm.njev(), 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, LevenbergMarquardtSpace::RelativeReductionTooSmall);
  // VERIFY_IS_EQUAL(lm.nfev(), 6);
  // VERIFY_IS_EQUAL(lm.njev(), 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, 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.setFtol(1.E6 * NumTraits<double>::epsilon());
  lm.setXtol(1.E6 * NumTraits<double>::epsilon());
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  // VERIFY_IS_EQUAL(lm.nfev(), 27);
  // VERIFY_IS_EQUAL(lm.njev(), 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.setFtol(1.E5 * NumTraits<double>::epsilon());
  lm.setXtol(1.E5 * NumTraits<double>::epsilon());
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  // VERIFY_IS_EQUAL(lm.nfev(), 9);
  // VERIFY_IS_EQUAL(lm.njev(), 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, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), Eigen::LevenbergMarquardt< FunctorType_ >::setFtol(), Eigen::LevenbergMarquardt< FunctorType_ >::setXtol(), VERIFY_IS_APPROX, and plotDoE::x.

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.setFtol(1.E4 * NumTraits<double>::epsilon());
  lm.setXtol(1.E4 * NumTraits<double>::epsilon());
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  // VERIFY_IS_EQUAL(lm.nfev(), 39);
  // VERIFY_IS_EQUAL(lm.njev(), 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.setFtol(1.E4 * NumTraits<double>::epsilon());
  lm.setXtol(1.E4 * NumTraits<double>::epsilon());
  info = lm.minimize(x);
  EIGEN_UNUSED_VARIABLE(info)
 
  // check return value
  // VERIFY_IS_EQUAL(info, 1);
  // VERIFY_IS_EQUAL(lm.nfev(), 29);
  // VERIFY_IS_EQUAL(lm.njev(), 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, Eigen::LevenbergMarquardt< FunctorType_ >::fvec, info, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), Eigen::LevenbergMarquardt< FunctorType_ >::setFtol(), Eigen::LevenbergMarquardt< FunctorType_ >::setXtol(), VERIFY_IS_APPROX, and plotDoE::x.

Referenced by EIGEN_DECLARE_TEST().