Eigen::LevenbergMarquardt< FunctorType_ > Class Template Reference

Performs non linear optimization over a non-linear function, using a variant of the Levenberg Marquardt algorithm. More...

#include <LevenbergMarquardt.h>

Inheritance diagram for Eigen::LevenbergMarquardt< FunctorType_ >:

Classes
struct	Parameters

Public Types
typedef FunctorType_	FunctorType
typedef FunctorType::QRSolver	QRSolver
typedef FunctorType::JacobianType	JacobianType
typedef JacobianType::Scalar	Scalar
typedef JacobianType::RealScalar	RealScalar
typedef QRSolver::StorageIndex	PermIndex
typedef Matrix< Scalar, Dynamic, 1 >	FVectorType
typedef PermutationMatrix< Dynamic, Dynamic, int >	PermutationType
typedef DenseIndex	Index
typedef Matrix< Scalar, Dynamic, 1 >	FVectorType
typedef Matrix< Scalar, Dynamic, Dynamic >	JacobianType

Public Member Functions
	LevenbergMarquardt (FunctorType &functor)
LevenbergMarquardtSpace::Status	minimize (FVectorType &x)
LevenbergMarquardtSpace::Status	minimizeInit (FVectorType &x)
LevenbergMarquardtSpace::Status	minimizeOneStep (FVectorType &x)
LevenbergMarquardtSpace::Status	lmder1 (FVectorType &x, const Scalar tol=std::sqrt(NumTraits< Scalar >::epsilon()))
void	resetParameters ()
void	setXtol (RealScalar xtol)
void	setFtol (RealScalar ftol)
void	setGtol (RealScalar gtol)
void	setFactor (RealScalar factor)
void	setEpsilon (RealScalar epsfcn)
void	setMaxfev (Index maxfev)
void	setExternalScaling (bool value)
RealScalar	xtol () const
RealScalar	ftol () const
RealScalar	gtol () const
RealScalar	factor () const
RealScalar	epsilon () const
Index	maxfev () const
FVectorType &	diag ()
Index	iterations ()
Index	nfev ()
Index	njev ()
RealScalar	fnorm ()
RealScalar	gnorm ()
RealScalar	lm_param (void)
FVectorType &	fvec ()
JacobianType &	jacobian ()
JacobianType &	matrixR ()
PermutationType	permutation ()
ComputationInfo	info () const
	Reports whether the minimization was successful. More...
	LevenbergMarquardt (FunctorType &_functor)
LevenbergMarquardtSpace::Status	lmder1 (FVectorType &x, const Scalar tol=sqrt_epsilon())
LevenbergMarquardtSpace::Status	minimize (FVectorType &x)
LevenbergMarquardtSpace::Status	minimizeInit (FVectorType &x)
LevenbergMarquardtSpace::Status	minimizeOneStep (FVectorType &x)
LevenbergMarquardtSpace::Status	lmstr1 (FVectorType &x, const Scalar tol=sqrt_epsilon())
LevenbergMarquardtSpace::Status	minimizeOptimumStorage (FVectorType &x)
LevenbergMarquardtSpace::Status	minimizeOptimumStorageInit (FVectorType &x)
LevenbergMarquardtSpace::Status	minimizeOptimumStorageOneStep (FVectorType &x)
void	resetParameters (void)
Scalar	lm_param (void)

Static Public Member Functions
static LevenbergMarquardtSpace::Status	lmdif1 (FunctorType &functor, FVectorType &x, Index *nfev, const Scalar tol=std::sqrt(NumTraits< Scalar >::epsilon()))
static LevenbergMarquardtSpace::Status	lmdif1 (FunctorType &functor, FVectorType &x, Index *nfev, const Scalar tol=sqrt_epsilon())

Public Attributes
Parameters	parameters
FVectorType	fvec
FVectorType	qtf
FVectorType	diag
JacobianType	fjac
PermutationMatrix< Dynamic, Dynamic >	permutation
Index	nfev
Index	njev
Index	iter
Scalar	fnorm
Scalar	gnorm
bool	useExternalScaling

Private Member Functions
LevenbergMarquardt &	operator= (const LevenbergMarquardt &)

Static Private Member Functions
static Scalar	sqrt_epsilon ()

Private Attributes
JacobianType	m_fjac
JacobianType	m_rfactor
FunctorType &	m_functor
FVectorType	m_fvec
FVectorType	m_qtf
FVectorType	m_diag
Index	n
Index	m
Index	m_nfev
Index	m_njev
RealScalar	m_fnorm
RealScalar	m_gnorm
RealScalar	m_factor
Index	m_maxfev
RealScalar	m_ftol
RealScalar	m_xtol
RealScalar	m_gtol
RealScalar	m_epsfcn
Index	m_iter
RealScalar	m_delta
bool	m_useExternalScaling
PermutationType	m_permutation
FVectorType	m_wa1
FVectorType	m_wa2
FVectorType	m_wa3
FVectorType	m_wa4
RealScalar	m_par
bool	m_isInitialized
ComputationInfo	m_info
FunctorType &	functor
FVectorType	wa1
FVectorType	wa2
FVectorType	wa3
FVectorType	wa4
Scalar	par
Scalar	sum
Scalar	temp
Scalar	temp1
Scalar	temp2
Scalar	delta
Scalar	ratio
Scalar	pnorm
Scalar	xnorm
Scalar	fnorm1
Scalar	actred
Scalar	dirder
Scalar	prered

Detailed Description

template<typename FunctorType_>
class Eigen::LevenbergMarquardt< FunctorType_ >

Performs non linear optimization over a non-linear function, using a variant of the Levenberg Marquardt algorithm.

Check wikipedia for more information. http://en.wikipedia.org/wiki/Levenberg%E2%80%93Marquardt_algorithm

Member Typedef Documentation

FunctorType

template<typename FunctorType_ >

typedef FunctorType_ Eigen::LevenbergMarquardt< FunctorType_ >::FunctorType

FVectorType [1/2]

template<typename FunctorType_ >

typedef Matrix<Scalar, Dynamic, 1> Eigen::LevenbergMarquardt< FunctorType_ >::FVectorType

FVectorType [2/2]

template<typename FunctorType_ >

typedef Matrix<Scalar, Dynamic, 1> Eigen::LevenbergMarquardt< FunctorType_ >::FVectorType

Index

template<typename FunctorType_ >

typedef DenseIndex Eigen::LevenbergMarquardt< FunctorType_ >::Index

JacobianType [1/2]

template<typename FunctorType_ >

typedef FunctorType::JacobianType Eigen::LevenbergMarquardt< FunctorType_ >::JacobianType

JacobianType [2/2]

template<typename FunctorType_ >

typedef Matrix<Scalar, Dynamic, Dynamic> Eigen::LevenbergMarquardt< FunctorType_ >::JacobianType

PermIndex

template<typename FunctorType_ >

typedef QRSolver::StorageIndex Eigen::LevenbergMarquardt< FunctorType_ >::PermIndex

PermutationType

template<typename FunctorType_ >

typedef PermutationMatrix<Dynamic, Dynamic, int> Eigen::LevenbergMarquardt< FunctorType_ >::PermutationType

QRSolver

template<typename FunctorType_ >

typedef FunctorType::QRSolver Eigen::LevenbergMarquardt< FunctorType_ >::QRSolver

RealScalar

template<typename FunctorType_ >

typedef JacobianType::RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::RealScalar

Scalar

template<typename FunctorType_ >

typedef JacobianType::Scalar Eigen::LevenbergMarquardt< FunctorType_ >::Scalar

Constructor & Destructor Documentation

LevenbergMarquardt() [1/2]

template<typename FunctorType_ >

Eigen::LevenbergMarquardt< FunctorType_ >::LevenbergMarquardt ( FunctorType &  functor )

inline

      : m_functor(functor),
        m_nfev(0),
        m_njev(0),
        m_fnorm(0.0),
        m_gnorm(0),
        m_isInitialized(false),
        m_info(InvalidInput) {
    resetParameters();
    m_useExternalScaling = false;
  }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_useExternalScaling, and Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters().

LevenbergMarquardt() [2/2]

template<typename FunctorType_ >

Eigen::LevenbergMarquardt< FunctorType_ >::LevenbergMarquardt ( FunctorType &  _functor )

inline

                                            : functor(_functor) {
    nfev = njev = iter = 0;
    fnorm = gnorm = 0.;
    useExternalScaling = false;
  }

References Eigen::LevenbergMarquardt< FunctorType_ >::fnorm, Eigen::LevenbergMarquardt< FunctorType_ >::gnorm, Eigen::LevenbergMarquardt< FunctorType_ >::iter, Eigen::LevenbergMarquardt< FunctorType_ >::nfev, Eigen::LevenbergMarquardt< FunctorType_ >::njev, and Eigen::LevenbergMarquardt< FunctorType_ >::useExternalScaling.

Member Function Documentation

diag()

template<typename FunctorType_ >

FVectorType& Eigen::LevenbergMarquardt< FunctorType_ >::diag ( )

inline

Returns

a reference to the diagonal of the jacobian

{ return m_diag; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_diag.

epsilon()

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::epsilon ( ) const

inline

Returns

the error precision

{ return m_epsfcn; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_epsfcn.

factor()

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::factor ( ) const

inline

Returns

the step bound for the diagonal shift

{ return m_factor; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_factor.

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::setFactor().

fnorm()

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::fnorm ( )

inline

Returns

the norm of current vector function

{ return m_fnorm; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_fnorm.

ftol()

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::ftol ( ) const

inline

Returns

the tolerance for the norm of the vector function

{ return m_ftol; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_ftol.

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::setFtol().

fvec()

template<typename FunctorType_ >

FVectorType& Eigen::LevenbergMarquardt< FunctorType_ >::fvec ( )

inline

Returns

a reference to the current vector function

{ return m_fvec; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_fvec.

gnorm()

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::gnorm ( )

inline

Returns

the norm of the gradient of the error

{ return m_gnorm; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_gnorm.

gtol()

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::gtol ( ) const

inline

Returns

the tolerance for the norm of the gradient of the error vector

{ return m_gtol; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_gtol.

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::setGtol().

info()

template<typename FunctorType_ >

ComputationInfo Eigen::LevenbergMarquardt< FunctorType_ >::info ( ) const

inline

Reports whether the minimization was successful.

Returns

Success if the minimization was successful, NumericalIssue if a numerical problem arises during the minimization process, for example during the QR factorization NoConvergence if the minimization did not converge after the maximum number of function evaluation allowed InvalidInput if the input matrix is invalid

{ return m_info; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_info.

iterations()

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::iterations ( )

inline

Returns

the number of iterations performed

{ return m_iter; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_iter.

jacobian()

template<typename FunctorType_ >

JacobianType& Eigen::LevenbergMarquardt< FunctorType_ >::jacobian ( )

inline

Returns

a reference to the matrix where the current Jacobian matrix is stored

{ return m_fjac; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_fjac.

lm_param() [1/2]

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::lm_param ( void  )

inline

Returns

the LevenbergMarquardt parameter

{ return m_par; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_par.

lm_param() [2/2]

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::lm_param ( void  )

inline

{ return par; }

References Eigen::LevenbergMarquardt< FunctorType_ >::par.

lmder1() [1/2]

template<typename FunctorType_ >

LevenbergMarquardtSpace::Status Eigen::LevenbergMarquardt< FunctorType_ >::lmder1	(	FVectorType &	x,
		const Scalar	tol = sqrt_epsilon()
	)

lmder1() [2/2]

template<typename FunctorType , typename Scalar >

LevenbergMarquardtSpace::Status Eigen::LevenbergMarquardt< FunctorType, Scalar >::lmder1	(	FVectorType &	x,
		const Scalar	tol = std::sqrt(NumTraits<Scalar>::epsilon())
	)

                                                                                                      {
  n = x.size();
  m = m_functor.values();
 
  /* check the input parameters for errors. */
  if (n <= 0 || m < n || tol < 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
 
  resetParameters();
  m_ftol = tol;
  m_xtol = tol;
  m_maxfev = 100 * (n + 1);
 
  return minimize(x);
}

References Eigen::LevenbergMarquardtSpace::ImproperInputParameters, m, n, and plotDoE::x.

Referenced by test_lmder(), and testLmder1().

lmdif1() [1/2]

template<typename FunctorType_ >

static LevenbergMarquardtSpace::Status Eigen::LevenbergMarquardt< FunctorType_ >::lmdif1 ( FunctorType &  functor, FVectorType &  x, Index *  nfev, const Scalar  tol = sqrt_epsilon()  )

static

lmdif1() [2/2]

template<typename FunctorType , typename Scalar >

LevenbergMarquardtSpace::Status Eigen::LevenbergMarquardt< FunctorType, Scalar >::lmdif1 ( FunctorType &  functor, FVectorType &  x, Index *  nfev, const Scalar  tol = std::sqrt(NumTraits<Scalar>::epsilon())  )

static

                                                                                                       {
  Index n = x.size();
  Index m = functor.values();
 
  /* check the input parameters for errors. */
  if (n <= 0 || m < n || tol < 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
 
  NumericalDiff<FunctorType> numDiff(functor);
  // embedded LevenbergMarquardt
  LevenbergMarquardt<NumericalDiff<FunctorType> > lm(numDiff);
  lm.setFtol(tol);
  lm.setXtol(tol);
  lm.setMaxfev(200 * (n + 1));
 
  LevenbergMarquardtSpace::Status info = LevenbergMarquardtSpace::Status(lm.minimize(x));
  if (nfev) *nfev = lm.nfev();
  return info;
}

References Eigen::LevenbergMarquardtSpace::ImproperInputParameters, info, m, Eigen::LevenbergMarquardt< FunctorType_ >::minimize(), n, Eigen::LevenbergMarquardt< FunctorType_ >::nfev, Eigen::LevenbergMarquardt< FunctorType_ >::setFtol(), Eigen::LevenbergMarquardt< FunctorType_ >::setMaxfev(), Eigen::LevenbergMarquardt< FunctorType_ >::setXtol(), and plotDoE::x.

lmstr1()

template<typename FunctorType , typename Scalar >

LevenbergMarquardtSpace::Status Eigen::LevenbergMarquardt< FunctorType, Scalar >::lmstr1	(	FVectorType &	x,
		const Scalar	tol = sqrt_epsilon()
	)

                                                                                                              {
  n = x.size();
  m = functor.values();
 
  /* check the input parameters for errors. */
  if (n <= 0 || m < n || tol < 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
 
  resetParameters();
  parameters.ftol = tol;
  parameters.xtol = tol;
  parameters.maxfev = 100 * (n + 1);
 
  return minimizeOptimumStorage(x);
}

References Eigen::LevenbergMarquardtSpace::ImproperInputParameters, m, n, and plotDoE::x.

Referenced by testLmstr1().

matrixR()

template<typename FunctorType_ >

JacobianType& Eigen::LevenbergMarquardt< FunctorType_ >::matrixR ( )

inline

Returns

a reference to the triangular matrix R from the QR of the jacobian matrix.

See also

jacobian()

{ return m_rfactor; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_rfactor.

Referenced by testLmder(), and testLmdif().

maxfev()

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::maxfev ( ) const

inline

Returns

the maximum number of function evaluation

{ return m_maxfev; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_maxfev.

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::setMaxfev().

minimize() [1/2]

template<typename FunctorType , typename Scalar >

LevenbergMarquardtSpace::Status Eigen::LevenbergMarquardt< FunctorType, Scalar >::minimize

(

FVectorType &

x

)

                                                                                      {
  LevenbergMarquardtSpace::Status status = minimizeInit(x);
  if (status == LevenbergMarquardtSpace::ImproperInputParameters) {
    m_isInitialized = true;
    return status;
  }
  do {
    //       std::cout << " uv " << x.transpose() << "\n";
    status = minimizeOneStep(x);
  } while (status == LevenbergMarquardtSpace::Running);
  m_isInitialized = true;
  return status;
}

References Eigen::LevenbergMarquardtSpace::ImproperInputParameters, Eigen::LevenbergMarquardtSpace::Running, and plotDoE::x.

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::lmdif1(), test_minimizeLM(), testLmder(), testLmdif(), testNistBennett5(), testNistBoxBOD(), testNistChwirut2(), testNistEckerle4(), testNistHahn1(), testNistLanczos1(), testNistMGH09(), testNistMGH10(), testNistMGH17(), testNistMisra1a(), testNistMisra1d(), testNistRat42(), testNistRat43(), and testNistThurber().

minimize() [2/2]

template<typename FunctorType_ >

LevenbergMarquardtSpace::Status Eigen::LevenbergMarquardt< FunctorType_ >::minimize

(

FVectorType &

x

)

minimizeInit() [1/2]

template<typename FunctorType , typename Scalar >

LevenbergMarquardtSpace::Status Eigen::LevenbergMarquardt< FunctorType, Scalar >::minimizeInit

(

FVectorType &

x

)

                                                                                          {
  n = x.size();
  m = m_functor.values();
 
  m_wa1.resize(n);
  m_wa2.resize(n);
  m_wa3.resize(n);
  m_wa4.resize(m);
  m_fvec.resize(m);
  // FIXME Sparse Case : Allocate space for the jacobian
  m_fjac.resize(m, n);
  //     m_fjac.reserve(VectorXi::Constant(n,5)); // FIXME Find a better alternative
  if (!m_useExternalScaling) m_diag.resize(n);
  eigen_assert((!m_useExternalScaling || m_diag.size() == n) &&
               "When m_useExternalScaling is set, the caller must provide a valid 'm_diag'");
  m_qtf.resize(n);
 
  /* Function Body */
  m_nfev = 0;
  m_njev = 0;
 
  /*     check the input parameters for errors. */
  if (n <= 0 || m < n || m_ftol < 0. || m_xtol < 0. || m_gtol < 0. || m_maxfev <= 0 || m_factor <= 0.) {
    m_info = InvalidInput;
    return LevenbergMarquardtSpace::ImproperInputParameters;
  }
 
  if (m_useExternalScaling)
    for (Index j = 0; j < n; ++j)
      if (m_diag[j] <= 0.) {
        m_info = InvalidInput;
        return LevenbergMarquardtSpace::ImproperInputParameters;
      }
 
  /*     evaluate the function at the starting point */
  /*     and calculate its norm. */
  m_nfev = 1;
  if (m_functor(x, m_fvec) < 0) return LevenbergMarquardtSpace::UserAsked;
  m_fnorm = m_fvec.stableNorm();
 
  /*     initialize levenberg-marquardt parameter and iteration counter. */
  m_par = 0.;
  m_iter = 1;
 
  return LevenbergMarquardtSpace::NotStarted;
}

References eigen_assert, Eigen::LevenbergMarquardtSpace::ImproperInputParameters, Eigen::InvalidInput, j, m, n, Eigen::LevenbergMarquardtSpace::NotStarted, Eigen::LevenbergMarquardtSpace::UserAsked, and plotDoE::x.

Referenced by test_minimizeSteps(), and test_sparseLM_T().

minimizeInit() [2/2]

template<typename FunctorType_ >

LevenbergMarquardtSpace::Status Eigen::LevenbergMarquardt< FunctorType_ >::minimizeInit

(

FVectorType &

x

)

minimizeOneStep() [1/2]

template<typename FunctorType , typename Scalar >

LevenbergMarquardtSpace::Status Eigen::LevenbergMarquardt< FunctorType, Scalar >::minimizeOneStep

(

FVectorType &

x

)

                                                                                             {
  using std::abs;
  using std::sqrt;
  RealScalar temp, temp1, temp2;
  RealScalar ratio;
  RealScalar pnorm, xnorm, fnorm1, actred, dirder, prered;
  eigen_assert(x.size() == n);  // check the caller is not cheating us
 
  temp = 0.0;
  xnorm = 0.0;
  /* calculate the jacobian matrix. */
  Index df_ret = m_functor.df(x, m_fjac);
  if (df_ret < 0) return LevenbergMarquardtSpace::UserAsked;
  if (df_ret > 0)
    // numerical diff, we evaluated the function df_ret times
    m_nfev += df_ret;
  else
    m_njev++;
 
  /* compute the qr factorization of the jacobian. */
  for (int j = 0; j < x.size(); ++j) m_wa2(j) = m_fjac.col(j).blueNorm();
  QRSolver qrfac(m_fjac);
  if (qrfac.info() != Success) {
    m_info = NumericalIssue;
    return LevenbergMarquardtSpace::ImproperInputParameters;
  }
  // Make a copy of the first factor with the associated permutation
  m_rfactor = qrfac.matrixR();
  m_permutation = (qrfac.colsPermutation());
 
  /* on the first iteration and if external scaling is not used, scale according */
  /* to the norms of the columns of the initial jacobian. */
  if (m_iter == 1) {
    if (!m_useExternalScaling)
      for (Index j = 0; j < n; ++j) m_diag[j] = (m_wa2[j] == 0.) ? 1. : m_wa2[j];
 
    /* on the first iteration, calculate the norm of the scaled x */
    /* and initialize the step bound m_delta. */
    xnorm = m_diag.cwiseProduct(x).stableNorm();
    m_delta = m_factor * xnorm;
    if (m_delta == 0.) m_delta = m_factor;
  }
 
  /* form (q transpose)*m_fvec and store the first n components in */
  /* m_qtf. */
  m_wa4 = m_fvec;
  m_wa4 = qrfac.matrixQ().adjoint() * m_fvec;
  m_qtf = m_wa4.head(n);
 
  /* compute the norm of the scaled gradient. */
  m_gnorm = 0.;
  if (m_fnorm != 0.)
    for (Index j = 0; j < n; ++j)
      if (m_wa2[m_permutation.indices()[j]] != 0.)
        m_gnorm = (std::max)(m_gnorm, abs(m_rfactor.col(j).head(j + 1).dot(m_qtf.head(j + 1) / m_fnorm) /
                                          m_wa2[m_permutation.indices()[j]]));
 
  /* test for convergence of the gradient norm. */
  if (m_gnorm <= m_gtol) {
    m_info = Success;
    return LevenbergMarquardtSpace::CosinusTooSmall;
  }
 
  /* rescale if necessary. */
  if (!m_useExternalScaling) m_diag = m_diag.cwiseMax(m_wa2);
 
  do {
    /* determine the levenberg-marquardt parameter. */
    internal::lmpar2(qrfac, m_diag, m_qtf, m_delta, m_par, m_wa1);
 
    /* store the direction p and x + p. calculate the norm of p. */
    m_wa1 = -m_wa1;
    m_wa2 = x + m_wa1;
    pnorm = m_diag.cwiseProduct(m_wa1).stableNorm();
 
    /* on the first iteration, adjust the initial step bound. */
    if (m_iter == 1) m_delta = (std::min)(m_delta, pnorm);
 
    /* evaluate the function at x + p and calculate its norm. */
    if (m_functor(m_wa2, m_wa4) < 0) return LevenbergMarquardtSpace::UserAsked;
    ++m_nfev;
    fnorm1 = m_wa4.stableNorm();
 
    /* compute the scaled actual reduction. */
    actred = -1.;
    if (Scalar(.1) * fnorm1 < m_fnorm) actred = 1. - numext::abs2(fnorm1 / m_fnorm);
 
    /* compute the scaled predicted reduction and */
    /* the scaled directional derivative. */
    m_wa3 = m_rfactor.template triangularView<Upper>() * (m_permutation.inverse() * m_wa1);
    temp1 = numext::abs2(m_wa3.stableNorm() / m_fnorm);
    temp2 = numext::abs2(sqrt(m_par) * pnorm / m_fnorm);
    prered = temp1 + temp2 / Scalar(.5);
    dirder = -(temp1 + temp2);
 
    /* compute the ratio of the actual to the predicted */
    /* reduction. */
    ratio = 0.;
    if (prered != 0.) ratio = actred / prered;
 
    /* update the step bound. */
    if (ratio <= Scalar(.25)) {
      if (actred >= 0.) temp = RealScalar(.5);
      if (actred < 0.) temp = RealScalar(.5) * dirder / (dirder + RealScalar(.5) * actred);
      if (RealScalar(.1) * fnorm1 >= m_fnorm || temp < RealScalar(.1)) temp = Scalar(.1);
      /* Computing MIN */
      m_delta = temp * (std::min)(m_delta, pnorm / RealScalar(.1));
      m_par /= temp;
    } else if (!(m_par != 0. && ratio < RealScalar(.75))) {
      m_delta = pnorm / RealScalar(.5);
      m_par = RealScalar(.5) * m_par;
    }
 
    /* test for successful iteration. */
    if (ratio >= RealScalar(1e-4)) {
      /* successful iteration. update x, m_fvec, and their norms. */
      x = m_wa2;
      m_wa2 = m_diag.cwiseProduct(x);
      m_fvec = m_wa4;
      xnorm = m_wa2.stableNorm();
      m_fnorm = fnorm1;
      ++m_iter;
    }
 
    /* tests for convergence. */
    if (abs(actred) <= m_ftol && prered <= m_ftol && Scalar(.5) * ratio <= 1. && m_delta <= m_xtol * xnorm) {
      m_info = Success;
      return LevenbergMarquardtSpace::RelativeErrorAndReductionTooSmall;
    }
    if (abs(actred) <= m_ftol && prered <= m_ftol && Scalar(.5) * ratio <= 1.) {
      m_info = Success;
      return LevenbergMarquardtSpace::RelativeReductionTooSmall;
    }
    if (m_delta <= m_xtol * xnorm) {
      m_info = Success;
      return LevenbergMarquardtSpace::RelativeErrorTooSmall;
    }
 
    /* tests for termination and stringent tolerances. */
    if (m_nfev >= m_maxfev) {
      m_info = NoConvergence;
      return LevenbergMarquardtSpace::TooManyFunctionEvaluation;
    }
    if (abs(actred) <= NumTraits<Scalar>::epsilon() && prered <= NumTraits<Scalar>::epsilon() &&
        Scalar(.5) * ratio <= 1.) {
      m_info = Success;
      return LevenbergMarquardtSpace::FtolTooSmall;
    }
    if (m_delta <= NumTraits<Scalar>::epsilon() * xnorm) {
      m_info = Success;
      return LevenbergMarquardtSpace::XtolTooSmall;
    }
    if (m_gnorm <= NumTraits<Scalar>::epsilon()) {
      m_info = Success;
      return LevenbergMarquardtSpace::GtolTooSmall;
    }
 
  } while (ratio < Scalar(1e-4));
 
  return LevenbergMarquardtSpace::Running;
}

References abs(), Eigen::numext::abs2(), Eigen::LevenbergMarquardtSpace::CosinusTooSmall, e(), eigen_assert, Eigen::LevenbergMarquardtSpace::FtolTooSmall, Eigen::LevenbergMarquardtSpace::GtolTooSmall, Eigen::LevenbergMarquardtSpace::ImproperInputParameters, j, Eigen::internal::lmpar2(), max, min, n, Eigen::NoConvergence, Eigen::NumericalIssue, Eigen::LevenbergMarquardtSpace::RelativeErrorAndReductionTooSmall, Eigen::LevenbergMarquardtSpace::RelativeErrorTooSmall, Eigen::LevenbergMarquardtSpace::RelativeReductionTooSmall, Eigen::LevenbergMarquardtSpace::Running, sqrt(), Eigen::Success, Eigen::LevenbergMarquardtSpace::TooManyFunctionEvaluation, Eigen::LevenbergMarquardtSpace::UserAsked, plotDoE::x, and Eigen::LevenbergMarquardtSpace::XtolTooSmall.

Referenced by test_minimizeSteps().

minimizeOneStep() [2/2]

template<typename FunctorType_ >

LevenbergMarquardtSpace::Status Eigen::LevenbergMarquardt< FunctorType_ >::minimizeOneStep

(

FVectorType &

x

)

minimizeOptimumStorage()

template<typename FunctorType , typename Scalar >

LevenbergMarquardtSpace::Status Eigen::LevenbergMarquardt< FunctorType, Scalar >::minimizeOptimumStorage

(

FVectorType &

x

)

                                                                                                            {
  LevenbergMarquardtSpace::Status status = minimizeOptimumStorageInit(x);
  if (status == LevenbergMarquardtSpace::ImproperInputParameters) return status;
  do {
    status = minimizeOptimumStorageOneStep(x);
  } while (status == LevenbergMarquardtSpace::Running);
  return status;
}

References Eigen::LevenbergMarquardtSpace::ImproperInputParameters, Eigen::LevenbergMarquardtSpace::Running, and plotDoE::x.

Referenced by testLmstr().

minimizeOptimumStorageInit()

template<typename FunctorType , typename Scalar >

LevenbergMarquardtSpace::Status Eigen::LevenbergMarquardt< FunctorType, Scalar >::minimizeOptimumStorageInit

(

FVectorType &

x

)

                                                                                                                {
  n = x.size();
  m = functor.values();
 
  wa1.resize(n);
  wa2.resize(n);
  wa3.resize(n);
  wa4.resize(m);
  fvec.resize(m);
  // Only R is stored in fjac. Q is only used to compute 'qtf', which is
  // Q.transpose()*rhs. qtf will be updated using givens rotation,
  // instead of storing them in Q.
  // The purpose it to only use a nxn matrix, instead of mxn here, so
  // that we can handle cases where m>>n :
  fjac.resize(n, n);
  if (!useExternalScaling) diag.resize(n);
  eigen_assert((!useExternalScaling || diag.size() == n) &&
               "When useExternalScaling is set, the caller must provide a valid 'diag'");
  qtf.resize(n);
 
  /* Function Body */
  nfev = 0;
  njev = 0;
 
  /*     check the input parameters for errors. */
  if (n <= 0 || m < n || parameters.ftol < 0. || parameters.xtol < 0. || parameters.gtol < 0. ||
      parameters.maxfev <= 0 || parameters.factor <= 0.)
    return LevenbergMarquardtSpace::ImproperInputParameters;
 
  if (useExternalScaling)
    for (Index j = 0; j < n; ++j)
      if (diag[j] <= 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
 
  /*     evaluate the function at the starting point */
  /*     and calculate its norm. */
  nfev = 1;
  if (functor(x, fvec) < 0) return LevenbergMarquardtSpace::UserAsked;
  fnorm = fvec.stableNorm();
 
  /*     initialize levenberg-marquardt parameter and iteration counter. */
  par = 0.;
  iter = 1;
 
  return LevenbergMarquardtSpace::NotStarted;
}

References diag, eigen_assert, Eigen::LevenbergMarquardtSpace::ImproperInputParameters, j, m, n, Eigen::LevenbergMarquardtSpace::NotStarted, calibrate::par, Eigen::LevenbergMarquardtSpace::UserAsked, and plotDoE::x.

minimizeOptimumStorageOneStep()

template<typename FunctorType , typename Scalar >

LevenbergMarquardtSpace::Status Eigen::LevenbergMarquardt< FunctorType, Scalar >::minimizeOptimumStorageOneStep

(

FVectorType &

x

)

                                                                                                                   {
  using std::abs;
  using std::sqrt;
 
  eigen_assert(x.size() == n);  // check the caller is not cheating us
 
  Index i, j;
  bool sing;
 
  /* compute the qr factorization of the jacobian matrix */
  /* calculated one row at a time, while simultaneously */
  /* forming (q transpose)*fvec and storing the first */
  /* n components in qtf. */
  qtf.fill(0.);
  fjac.fill(0.);
  Index rownb = 2;
  for (i = 0; i < m; ++i) {
    if (functor.df(x, wa3, rownb) < 0) return LevenbergMarquardtSpace::UserAsked;
    internal::rwupdt<Scalar>(fjac, wa3, qtf, fvec[i]);
    ++rownb;
  }
  ++njev;
 
  /* if the jacobian is rank deficient, call qrfac to */
  /* reorder its columns and update the components of qtf. */
  sing = false;
  for (j = 0; j < n; ++j) {
    if (fjac(j, j) == 0.) sing = true;
    wa2[j] = fjac.col(j).head(j).stableNorm();
  }
  permutation.setIdentity(n);
  if (sing) {
    wa2 = fjac.colwise().blueNorm();
    // TODO We have no unit test covering this code path, do not modify
    // until it is carefully tested
    ColPivHouseholderQR<JacobianType> qrfac(fjac);
    fjac = qrfac.matrixQR();
    wa1 = fjac.diagonal();
    fjac.diagonal() = qrfac.hCoeffs();
    permutation = qrfac.colsPermutation();
    // TODO : avoid this:
    for (Index ii = 0; ii < fjac.cols(); ii++)
      fjac.col(ii).segment(ii + 1, fjac.rows() - ii - 1) *= fjac(ii, ii);  // rescale vectors
 
    for (j = 0; j < n; ++j) {
      if (fjac(j, j) != 0.) {
        sum = 0.;
        for (i = j; i < n; ++i) sum += fjac(i, j) * qtf[i];
        temp = -sum / fjac(j, j);
        for (i = j; i < n; ++i) qtf[i] += fjac(i, j) * temp;
      }
      fjac(j, j) = wa1[j];
    }
  }
 
  /* on the first iteration and if external scaling is not used, scale according */
  /* to the norms of the columns of the initial jacobian. */
  if (iter == 1) {
    if (!useExternalScaling)
      for (j = 0; j < n; ++j) diag[j] = (wa2[j] == 0.) ? 1. : wa2[j];
 
    /* on the first iteration, calculate the norm of the scaled x */
    /* and initialize the step bound delta. */
    xnorm = diag.cwiseProduct(x).stableNorm();
    delta = parameters.factor * xnorm;
    if (delta == 0.) delta = parameters.factor;
  }
 
  /* compute the norm of the scaled gradient. */
  gnorm = 0.;
  if (fnorm != 0.)
    for (j = 0; j < n; ++j)
      if (wa2[permutation.indices()[j]] != 0.)
        gnorm = (std::max)(gnorm,
                           abs(fjac.col(j).head(j + 1).dot(qtf.head(j + 1) / fnorm) / wa2[permutation.indices()[j]]));
 
  /* test for convergence of the gradient norm. */
  if (gnorm <= parameters.gtol) return LevenbergMarquardtSpace::CosinusTooSmall;
 
  /* rescale if necessary. */
  if (!useExternalScaling) diag = diag.cwiseMax(wa2);
 
  do {
    /* determine the levenberg-marquardt parameter. */
    internal::lmpar<Scalar>(fjac, permutation.indices(), diag, qtf, delta, par, wa1);
 
    /* store the direction p and x + p. calculate the norm of p. */
    wa1 = -wa1;
    wa2 = x + wa1;
    pnorm = diag.cwiseProduct(wa1).stableNorm();
 
    /* on the first iteration, adjust the initial step bound. */
    if (iter == 1) delta = (std::min)(delta, pnorm);
 
    /* evaluate the function at x + p and calculate its norm. */
    if (functor(wa2, wa4) < 0) return LevenbergMarquardtSpace::UserAsked;
    ++nfev;
    fnorm1 = wa4.stableNorm();
 
    /* compute the scaled actual reduction. */
    actred = -1.;
    if (Scalar(.1) * fnorm1 < fnorm) actred = 1. - numext::abs2(fnorm1 / fnorm);
 
    /* compute the scaled predicted reduction and */
    /* the scaled directional derivative. */
    wa3 = fjac.topLeftCorner(n, n).template triangularView<Upper>() * (permutation.inverse() * wa1);
    temp1 = numext::abs2(wa3.stableNorm() / fnorm);
    temp2 = numext::abs2(sqrt(par) * pnorm / fnorm);
    prered = temp1 + temp2 / Scalar(.5);
    dirder = -(temp1 + temp2);
 
    /* compute the ratio of the actual to the predicted */
    /* reduction. */
    ratio = 0.;
    if (prered != 0.) ratio = actred / prered;
 
    /* update the step bound. */
    if (ratio <= Scalar(.25)) {
      if (actred >= 0.) temp = Scalar(.5);
      if (actred < 0.) temp = Scalar(.5) * dirder / (dirder + Scalar(.5) * actred);
      if (Scalar(.1) * fnorm1 >= fnorm || temp < Scalar(.1)) temp = Scalar(.1);
      /* Computing MIN */
      delta = temp * (std::min)(delta, pnorm / Scalar(.1));
      par /= temp;
    } else if (!(par != 0. && ratio < Scalar(.75))) {
      delta = pnorm / Scalar(.5);
      par = Scalar(.5) * par;
    }
 
    /* test for successful iteration. */
    if (ratio >= Scalar(1e-4)) {
      /* successful iteration. update x, fvec, and their norms. */
      x = wa2;
      wa2 = diag.cwiseProduct(x);
      fvec = wa4;
      xnorm = wa2.stableNorm();
      fnorm = fnorm1;
      ++iter;
    }
 
    /* tests for convergence. */
    if (abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1. &&
        delta <= parameters.xtol * xnorm)
      return LevenbergMarquardtSpace::RelativeErrorAndReductionTooSmall;
    if (abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1.)
      return LevenbergMarquardtSpace::RelativeReductionTooSmall;
    if (delta <= parameters.xtol * xnorm) return LevenbergMarquardtSpace::RelativeErrorTooSmall;
 
    /* tests for termination and stringent tolerances. */
    if (nfev >= parameters.maxfev) return LevenbergMarquardtSpace::TooManyFunctionEvaluation;
    if (abs(actred) <= NumTraits<Scalar>::epsilon() && prered <= NumTraits<Scalar>::epsilon() &&
        Scalar(.5) * ratio <= 1.)
      return LevenbergMarquardtSpace::FtolTooSmall;
    if (delta <= NumTraits<Scalar>::epsilon() * xnorm) return LevenbergMarquardtSpace::XtolTooSmall;
    if (gnorm <= NumTraits<Scalar>::epsilon()) return LevenbergMarquardtSpace::GtolTooSmall;
 
  } while (ratio < Scalar(1e-4));
 
  return LevenbergMarquardtSpace::Running;
}

References abs(), Eigen::numext::abs2(), Eigen::ColPivHouseholderQR< MatrixType_, PermutationIndex_ >::colsPermutation(), Eigen::LevenbergMarquardtSpace::CosinusTooSmall, MultiOpt::delta, diag, e(), eigen_assert, Eigen::LevenbergMarquardtSpace::FtolTooSmall, Eigen::LevenbergMarquardtSpace::GtolTooSmall, Eigen::ColPivHouseholderQR< MatrixType_, PermutationIndex_ >::hCoeffs(), i, j, m, Eigen::ColPivHouseholderQR< MatrixType_, PermutationIndex_ >::matrixQR(), max, min, n, calibrate::par, Eigen::LevenbergMarquardtSpace::RelativeErrorAndReductionTooSmall, Eigen::LevenbergMarquardtSpace::RelativeErrorTooSmall, Eigen::LevenbergMarquardtSpace::RelativeReductionTooSmall, Eigen::LevenbergMarquardtSpace::Running, sqrt(), Eigen::LevenbergMarquardtSpace::TooManyFunctionEvaluation, Eigen::LevenbergMarquardtSpace::UserAsked, plotDoE::x, and Eigen::LevenbergMarquardtSpace::XtolTooSmall.

nfev()

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::nfev ( )

inline

Returns

the number of functions evaluation

{ return m_nfev; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_nfev.

njev()

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::njev ( )

inline

Returns

the number of jacobian evaluation

{ return m_njev; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_njev.

operator=()

template<typename FunctorType_ >

LevenbergMarquardt& Eigen::LevenbergMarquardt< FunctorType_ >::operator= ( const LevenbergMarquardt< FunctorType_ > &  )

private

permutation()

template<typename FunctorType_ >

PermutationType Eigen::LevenbergMarquardt< FunctorType_ >::permutation ( )

inline

the permutation used in the QR factorization

{ return m_permutation; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_permutation.

resetParameters() [1/2]

template<typename FunctorType_ >

void Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters ( )

inline

Sets the default parameters

                         {
    using std::sqrt;
 
    m_factor = 100.;
    m_maxfev = 400;
    m_ftol = sqrt(NumTraits<RealScalar>::epsilon());
    m_xtol = sqrt(NumTraits<RealScalar>::epsilon());
    m_gtol = 0.;
    m_epsfcn = 0.;
  }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_epsfcn, Eigen::LevenbergMarquardt< FunctorType_ >::m_factor, Eigen::LevenbergMarquardt< FunctorType_ >::m_ftol, Eigen::LevenbergMarquardt< FunctorType_ >::m_gtol, Eigen::LevenbergMarquardt< FunctorType_ >::m_maxfev, Eigen::LevenbergMarquardt< FunctorType_ >::m_xtol, and sqrt().

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::LevenbergMarquardt(), testNistBennett5(), testNistBoxBOD(), testNistChwirut2(), testNistMGH09(), testNistMGH17(), testNistRat43(), and testNistThurber().

resetParameters() [2/2]

template<typename FunctorType_ >

void Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters ( void  )

inline

{ parameters = Parameters(); }

References Eigen::LevenbergMarquardt< FunctorType_ >::parameters.

setEpsilon()

template<typename FunctorType_ >

void Eigen::LevenbergMarquardt< FunctorType_ >::setEpsilon ( RealScalar  epsfcn )

inline

Sets the error precision

{ m_epsfcn = epsfcn; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_epsfcn.

setExternalScaling()

template<typename FunctorType_ >

void Eigen::LevenbergMarquardt< FunctorType_ >::setExternalScaling ( bool  value )

inline

Use an external Scaling. If set to true, pass a nonzero diagonal to diag()

{ m_useExternalScaling = value; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_useExternalScaling, and Eigen::value.

setFactor()

template<typename FunctorType_ >

void Eigen::LevenbergMarquardt< FunctorType_ >::setFactor ( RealScalar  factor )

inline

Sets the step bound for the diagonal shift

{ m_factor = factor; }

References Eigen::LevenbergMarquardt< FunctorType_ >::factor(), and Eigen::LevenbergMarquardt< FunctorType_ >::m_factor.

Referenced by testNistBoxBOD().

setFtol()

template<typename FunctorType_ >

void Eigen::LevenbergMarquardt< FunctorType_ >::setFtol ( RealScalar  ftol )

inline

Sets the tolerance for the norm of the vector function

{ m_ftol = ftol; }

References Eigen::LevenbergMarquardt< FunctorType_ >::ftol(), and Eigen::LevenbergMarquardt< FunctorType_ >::m_ftol.

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::lmdif1(), testNistBoxBOD(), testNistChwirut2(), testNistMGH17(), testNistRat43(), and testNistThurber().

setGtol()

template<typename FunctorType_ >

void Eigen::LevenbergMarquardt< FunctorType_ >::setGtol ( RealScalar  gtol )

inline

Sets the tolerance for the norm of the gradient of the error vector

{ m_gtol = gtol; }

References Eigen::LevenbergMarquardt< FunctorType_ >::gtol(), and Eigen::LevenbergMarquardt< FunctorType_ >::m_gtol.

setMaxfev()

template<typename FunctorType_ >

void Eigen::LevenbergMarquardt< FunctorType_ >::setMaxfev ( Index  maxfev )

inline

Sets the maximum number of function evaluation

{ m_maxfev = maxfev; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_maxfev, and Eigen::LevenbergMarquardt< FunctorType_ >::maxfev().

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::lmdif1(), testNistBennett5(), testNistMGH09(), and testNistMGH17().

setXtol()

template<typename FunctorType_ >

void Eigen::LevenbergMarquardt< FunctorType_ >::setXtol ( RealScalar  xtol )

inline

Sets the tolerance for the norm of the solution vector

{ m_xtol = xtol; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_xtol, and Eigen::LevenbergMarquardt< FunctorType_ >::xtol().

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::lmdif1(), testNistBoxBOD(), testNistChwirut2(), testNistMGH17(), testNistRat43(), and testNistThurber().

sqrt_epsilon()

template<typename FunctorType_ >

static Scalar Eigen::LevenbergMarquardt< FunctorType_ >::sqrt_epsilon ( )

inlinestaticprivate

                               {
    using std::sqrt;
    return sqrt(NumTraits<Scalar>::epsilon());
  }

References sqrt().

xtol()

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::xtol ( ) const

inline

Returns

the tolerance for the norm of the solution vector

{ return m_xtol; }

References Eigen::LevenbergMarquardt< FunctorType_ >::m_xtol.

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::setXtol().

Member Data Documentation

actred

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::actred

private

delta

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::delta

private

diag

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::diag

dirder

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::dirder

private

fjac

template<typename FunctorType_ >

JacobianType Eigen::LevenbergMarquardt< FunctorType_ >::fjac

Referenced by testLmder(), and testLmdif().

fnorm

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::fnorm

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::LevenbergMarquardt().

fnorm1

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::fnorm1

private

functor

template<typename FunctorType_ >

FunctorType& Eigen::LevenbergMarquardt< FunctorType_ >::functor

private

fvec

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::fvec

Referenced by testLmder(), testLmder1(), testLmdif(), testLmstr(), testLmstr1(), testNistBennett5(), testNistBoxBOD(), testNistChwirut2(), testNistEckerle4(), testNistHahn1(), testNistLanczos1(), testNistMGH09(), testNistMGH10(), testNistMGH17(), testNistMisra1a(), testNistMisra1d(), testNistRat42(), testNistRat43(), and testNistThurber().

gnorm

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::gnorm

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::LevenbergMarquardt().

iter

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::iter

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::LevenbergMarquardt().

m

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::m

private

m_delta

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_delta

private

m_diag

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::m_diag

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::diag().

m_epsfcn

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_epsfcn

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::epsilon(), Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), and Eigen::LevenbergMarquardt< FunctorType_ >::setEpsilon().

m_factor

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_factor

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::factor(), Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), and Eigen::LevenbergMarquardt< FunctorType_ >::setFactor().

m_fjac

template<typename FunctorType_ >

JacobianType Eigen::LevenbergMarquardt< FunctorType_ >::m_fjac

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::jacobian().

m_fnorm

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_fnorm

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::fnorm().

m_ftol

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_ftol

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::ftol(), Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), and Eigen::LevenbergMarquardt< FunctorType_ >::setFtol().

m_functor

template<typename FunctorType_ >

FunctorType& Eigen::LevenbergMarquardt< FunctorType_ >::m_functor

private

m_fvec

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::m_fvec

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::fvec().

m_gnorm

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_gnorm

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::gnorm().

m_gtol

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_gtol

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::gtol(), Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), and Eigen::LevenbergMarquardt< FunctorType_ >::setGtol().

m_info

template<typename FunctorType_ >

ComputationInfo Eigen::LevenbergMarquardt< FunctorType_ >::m_info

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::info().

m_isInitialized

template<typename FunctorType_ >

bool Eigen::LevenbergMarquardt< FunctorType_ >::m_isInitialized

private

m_iter

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::m_iter

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::iterations().

m_maxfev

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::m_maxfev

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::maxfev(), Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), and Eigen::LevenbergMarquardt< FunctorType_ >::setMaxfev().

m_nfev

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::m_nfev

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::nfev().

m_njev

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::m_njev

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::njev().

m_par

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_par

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::lm_param().

m_permutation

template<typename FunctorType_ >

PermutationType Eigen::LevenbergMarquardt< FunctorType_ >::m_permutation

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::permutation().

m_qtf

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::m_qtf

private

m_rfactor

template<typename FunctorType_ >

JacobianType Eigen::LevenbergMarquardt< FunctorType_ >::m_rfactor

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::matrixR().

m_useExternalScaling

template<typename FunctorType_ >

bool Eigen::LevenbergMarquardt< FunctorType_ >::m_useExternalScaling

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::LevenbergMarquardt(), and Eigen::LevenbergMarquardt< FunctorType_ >::setExternalScaling().

m_wa1

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::m_wa1

private

m_wa2

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::m_wa2

private

m_wa3

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::m_wa3

private

m_wa4

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::m_wa4

private

m_xtol

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_xtol

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), Eigen::LevenbergMarquardt< FunctorType_ >::setXtol(), and Eigen::LevenbergMarquardt< FunctorType_ >::xtol().

n

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::n

private

nfev

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::nfev

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::LevenbergMarquardt(), Eigen::LevenbergMarquardt< FunctorType_ >::lmdif1(), testLmdif(), testNistBoxBOD(), and testNistMGH10().

njev

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::njev

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::LevenbergMarquardt(), testNistBoxBOD(), and testNistMGH10().

par

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::par

private

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::lm_param().

parameters

template<typename FunctorType_ >

Parameters Eigen::LevenbergMarquardt< FunctorType_ >::parameters

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::resetParameters(), testNistBennett5(), testNistBoxBOD(), testNistChwirut2(), testNistMGH09(), testNistMGH17(), testNistRat43(), and testNistThurber().

permutation

template<typename FunctorType_ >

PermutationMatrix<Dynamic, Dynamic> Eigen::LevenbergMarquardt< FunctorType_ >::permutation

Referenced by testLmder(), and testLmdif().

pnorm

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::pnorm

private

prered

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::prered

private

qtf

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::qtf

ratio

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::ratio

private

sum

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::sum

private

temp

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::temp

private

temp1

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::temp1

private

temp2

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::temp2

private

useExternalScaling

template<typename FunctorType_ >

bool Eigen::LevenbergMarquardt< FunctorType_ >::useExternalScaling

Referenced by Eigen::LevenbergMarquardt< FunctorType_ >::LevenbergMarquardt().

wa1

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::wa1

private

wa2

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::wa2

private

wa3

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::wa3

private

wa4

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::wa4

private

xnorm

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::xnorm

private

---

The documentation for this class was generated from the following files:

• LevenbergMarquardt/LevenbergMarquardt.h
• LMonestep.h