Eigen::LevenbergMarquardt< FunctorType_ > Class Template Reference

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

Inherits internal::no_assignment_operator.

Classes
struct	Parameters

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

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

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

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

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

Static Private Member Functions
static Scalar	sqrt_epsilon ()

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

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

Definition at line 112 of file LevenbergMarquardt/LevenbergMarquardt.h.

Member Typedef Documentation

FunctorType

template<typename FunctorType_ >

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

Definition at line 115 of file LevenbergMarquardt/LevenbergMarquardt.h.

FVectorType [1/2]

template<typename FunctorType_ >

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

Definition at line 121 of file LevenbergMarquardt/LevenbergMarquardt.h.

FVectorType [2/2]

template<typename FunctorType_ >

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

Definition at line 78 of file NonLinearOptimization/LevenbergMarquardt.h.

Index

template<typename FunctorType_ >

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

Definition at line 60 of file NonLinearOptimization/LevenbergMarquardt.h.

JacobianType [1/2]

template<typename FunctorType_ >

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

Definition at line 117 of file LevenbergMarquardt/LevenbergMarquardt.h.

JacobianType [2/2]

template<typename FunctorType_ >

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

Definition at line 79 of file NonLinearOptimization/LevenbergMarquardt.h.

PermIndex

template<typename FunctorType_ >

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

Definition at line 120 of file LevenbergMarquardt/LevenbergMarquardt.h.

PermutationType

template<typename FunctorType_ >

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

Definition at line 122 of file LevenbergMarquardt/LevenbergMarquardt.h.

QRSolver

template<typename FunctorType_ >

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

Definition at line 116 of file LevenbergMarquardt/LevenbergMarquardt.h.

RealScalar

template<typename FunctorType_ >

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

Definition at line 119 of file LevenbergMarquardt/LevenbergMarquardt.h.

Scalar

template<typename FunctorType_ >

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

Definition at line 118 of file LevenbergMarquardt/LevenbergMarquardt.h.

Constructor & Destructor Documentation

LevenbergMarquardt() [1/2]

template<typename FunctorType_ >

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

inline

Definition at line 124 of file LevenbergMarquardt/LevenbergMarquardt.h.

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

LevenbergMarquardt() [2/2]

template<typename FunctorType_ >

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

inline

Definition at line 57 of file NonLinearOptimization/LevenbergMarquardt.h.

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

Member Function Documentation

diag()

template<typename FunctorType_ >

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

inline

Returns

a reference to the diagonal of the jacobian

Definition at line 199 of file LevenbergMarquardt/LevenbergMarquardt.h.

{return m_diag; }

epsilon()

template<typename FunctorType_ >

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

inline

Returns

the error precision

Definition at line 193 of file LevenbergMarquardt/LevenbergMarquardt.h.

{return m_epsfcn; }

factor()

template<typename FunctorType_ >

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

inline

Returns

the step bound for the diagonal shift

Definition at line 190 of file LevenbergMarquardt/LevenbergMarquardt.h.

{return m_factor; }

fnorm()

template<typename FunctorType_ >

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

inline

Returns

the norm of current vector function

Definition at line 211 of file LevenbergMarquardt/LevenbergMarquardt.h.

{return m_fnorm; }

ftol()

template<typename FunctorType_ >

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

inline

Returns

the tolerance for the norm of the vector function

Definition at line 184 of file LevenbergMarquardt/LevenbergMarquardt.h.

{return m_ftol; }

fvec()

template<typename FunctorType_ >

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

inline

Returns

a reference to the current vector function

Definition at line 221 of file LevenbergMarquardt/LevenbergMarquardt.h.

{return m_fvec; }

gnorm()

template<typename FunctorType_ >

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

inline

Returns

the norm of the gradient of the error

Definition at line 214 of file LevenbergMarquardt/LevenbergMarquardt.h.

{return 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

Definition at line 187 of file LevenbergMarquardt/LevenbergMarquardt.h.

{return m_gtol; }

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

Definition at line 245 of file LevenbergMarquardt/LevenbergMarquardt.h.

    {
      
      return m_info;
    }

iterations()

template<typename FunctorType_ >

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

inline

Returns

the number of iterations performed

Definition at line 202 of file LevenbergMarquardt/LevenbergMarquardt.h.

{ return 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

Definition at line 225 of file LevenbergMarquardt/LevenbergMarquardt.h.

{return m_fjac; }

lm_param() [1/2]

template<typename FunctorType_ >

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

inline

Returns

the LevenbergMarquardt parameter

Definition at line 217 of file LevenbergMarquardt/LevenbergMarquardt.h.

{ return m_par; }

lm_param() [2/2]

template<typename FunctorType_ >

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

inline

Definition at line 118 of file NonLinearOptimization/LevenbergMarquardt.h.

{ return 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())
	)

Definition at line 346 of file LevenbergMarquardt/LevenbergMarquardt.h.

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

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

Definition at line 369 of file LevenbergMarquardt/LevenbergMarquardt.h.

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

lmstr1()

template<typename FunctorType , typename Scalar >

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

Definition at line 365 of file NonLinearOptimization/LevenbergMarquardt.h.

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

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()

Definition at line 230 of file LevenbergMarquardt/LevenbergMarquardt.h.

{return m_rfactor; }

maxfev()

template<typename FunctorType_ >

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

inline

Returns

the maximum number of function evaluation

Definition at line 196 of file LevenbergMarquardt/LevenbergMarquardt.h.

{return m_maxfev; }

minimize() [1/2]

template<typename FunctorType , typename Scalar >

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

(

FVectorType &

x

)

Definition at line 279 of file LevenbergMarquardt/LevenbergMarquardt.h.

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

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

)

Definition at line 296 of file LevenbergMarquardt/LevenbergMarquardt.h.

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

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

)

Definition at line 23 of file LMonestep.h.

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

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

)

Definition at line 615 of file NonLinearOptimization/LevenbergMarquardt.h.

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

minimizeOptimumStorageInit()

template<typename FunctorType , typename Scalar >

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

(

FVectorType &

x

)

Definition at line 387 of file NonLinearOptimization/LevenbergMarquardt.h.

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

minimizeOptimumStorageOneStep()

template<typename FunctorType , typename Scalar >

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

(

FVectorType &

x

)

Definition at line 436 of file NonLinearOptimization/LevenbergMarquardt.h.

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

nfev()

template<typename FunctorType_ >

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

inline

Returns

the number of functions evaluation

Definition at line 205 of file LevenbergMarquardt/LevenbergMarquardt.h.

{ return m_nfev; }

njev()

template<typename FunctorType_ >

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

inline

Returns

the number of jacobian evaluation

Definition at line 208 of file LevenbergMarquardt/LevenbergMarquardt.h.

{ return 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

Definition at line 234 of file LevenbergMarquardt/LevenbergMarquardt.h.

{return m_permutation; }

resetParameters() [1/2]

template<typename FunctorType_ >

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

inline

Sets the default parameters

Definition at line 147 of file LevenbergMarquardt/LevenbergMarquardt.h.

    {
      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. ;
    }

resetParameters() [2/2]

template<typename FunctorType_ >

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

inline

Definition at line 106 of file NonLinearOptimization/LevenbergMarquardt.h.

{ parameters = Parameters(); }

setEpsilon()

template<typename FunctorType_ >

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

inline

Sets the error precision

Definition at line 172 of file LevenbergMarquardt/LevenbergMarquardt.h.

{ m_epsfcn = 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()

Definition at line 178 of file LevenbergMarquardt/LevenbergMarquardt.h.

{m_useExternalScaling  = value; }

setFactor()

template<typename FunctorType_ >

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

inline

Sets the step bound for the diagonal shift

Definition at line 169 of file LevenbergMarquardt/LevenbergMarquardt.h.

{ m_factor = factor; }    

setFtol()

template<typename FunctorType_ >

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

inline

Sets the tolerance for the norm of the vector function

Definition at line 163 of file LevenbergMarquardt/LevenbergMarquardt.h.

{ m_ftol = ftol; }

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

Definition at line 166 of file LevenbergMarquardt/LevenbergMarquardt.h.

{ m_gtol = gtol; }

setMaxfev()

template<typename FunctorType_ >

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

inline

Sets the maximum number of function evaluation

Definition at line 175 of file LevenbergMarquardt/LevenbergMarquardt.h.

{m_maxfev = maxfev; }

setXtol()

template<typename FunctorType_ >

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

inline

Sets the tolerance for the norm of the solution vector

Definition at line 160 of file LevenbergMarquardt/LevenbergMarquardt.h.

{ m_xtol = xtol; }

sqrt_epsilon()

template<typename FunctorType_ >

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

inlinestaticprivate

Definition at line 50 of file NonLinearOptimization/LevenbergMarquardt.h.

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

xtol()

template<typename FunctorType_ >

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

inline

Returns

the tolerance for the norm of the solution vector

Definition at line 181 of file LevenbergMarquardt/LevenbergMarquardt.h.

{return m_xtol; }

Member Data Documentation

actred

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::actred

private

Definition at line 130 of file NonLinearOptimization/LevenbergMarquardt.h.

delta

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::delta

private

Definition at line 128 of file NonLinearOptimization/LevenbergMarquardt.h.

diag

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::diag

Definition at line 109 of file NonLinearOptimization/LevenbergMarquardt.h.

dirder

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::dirder

private

Definition at line 130 of file NonLinearOptimization/LevenbergMarquardt.h.

fjac

template<typename FunctorType_ >

JacobianType Eigen::LevenbergMarquardt< FunctorType_ >::fjac

Definition at line 110 of file NonLinearOptimization/LevenbergMarquardt.h.

fnorm

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::fnorm

Definition at line 115 of file NonLinearOptimization/LevenbergMarquardt.h.

fnorm1

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::fnorm1

private

Definition at line 130 of file NonLinearOptimization/LevenbergMarquardt.h.

functor

template<typename FunctorType_ >

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

private

Definition at line 121 of file NonLinearOptimization/LevenbergMarquardt.h.

fvec

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::fvec

Definition at line 109 of file NonLinearOptimization/LevenbergMarquardt.h.

gnorm

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::gnorm

Definition at line 115 of file NonLinearOptimization/LevenbergMarquardt.h.

iter

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::iter

Definition at line 114 of file NonLinearOptimization/LevenbergMarquardt.h.

m

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::m

private

Definition at line 256 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_delta

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_delta

private

Definition at line 268 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_diag

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::m_diag

private

Definition at line 254 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_epsfcn

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_epsfcn

private

Definition at line 266 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_factor

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_factor

private

Definition at line 261 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_fjac

template<typename FunctorType_ >

JacobianType Eigen::LevenbergMarquardt< FunctorType_ >::m_fjac

private

Definition at line 251 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_fnorm

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_fnorm

private

Definition at line 259 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_ftol

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_ftol

private

Definition at line 263 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_functor

template<typename FunctorType_ >

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

private

Definition at line 253 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_fvec

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::m_fvec

private

Definition at line 254 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_gnorm

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_gnorm

private

Definition at line 260 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_gtol

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_gtol

private

Definition at line 265 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_info

template<typename FunctorType_ >

ComputationInfo Eigen::LevenbergMarquardt< FunctorType_ >::m_info

private

Definition at line 274 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_isInitialized

template<typename FunctorType_ >

bool Eigen::LevenbergMarquardt< FunctorType_ >::m_isInitialized

private

Definition at line 273 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_iter

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::m_iter

private

Definition at line 267 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_maxfev

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::m_maxfev

private

Definition at line 262 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_nfev

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::m_nfev

private

Definition at line 257 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_njev

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::m_njev

private

Definition at line 258 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_par

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_par

private

Definition at line 272 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_permutation

template<typename FunctorType_ >

PermutationType Eigen::LevenbergMarquardt< FunctorType_ >::m_permutation

private

Definition at line 270 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_qtf

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::m_qtf

private

Definition at line 254 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_rfactor

template<typename FunctorType_ >

JacobianType Eigen::LevenbergMarquardt< FunctorType_ >::m_rfactor

private

Definition at line 252 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_useExternalScaling

template<typename FunctorType_ >

bool Eigen::LevenbergMarquardt< FunctorType_ >::m_useExternalScaling

private

Definition at line 269 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_wa1

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::m_wa1

private

Definition at line 271 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_wa2

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::m_wa2

private

Definition at line 271 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_wa3

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::m_wa3

private

Definition at line 271 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_wa4

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::m_wa4

private

Definition at line 271 of file LevenbergMarquardt/LevenbergMarquardt.h.

m_xtol

template<typename FunctorType_ >

RealScalar Eigen::LevenbergMarquardt< FunctorType_ >::m_xtol

private

Definition at line 264 of file LevenbergMarquardt/LevenbergMarquardt.h.

n

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::n

private

Definition at line 255 of file LevenbergMarquardt/LevenbergMarquardt.h.

nfev

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::nfev

Definition at line 112 of file NonLinearOptimization/LevenbergMarquardt.h.

njev

template<typename FunctorType_ >

Index Eigen::LevenbergMarquardt< FunctorType_ >::njev

Definition at line 113 of file NonLinearOptimization/LevenbergMarquardt.h.

par

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::par

private

Definition at line 126 of file NonLinearOptimization/LevenbergMarquardt.h.

parameters

template<typename FunctorType_ >

Parameters Eigen::LevenbergMarquardt< FunctorType_ >::parameters

Definition at line 108 of file NonLinearOptimization/LevenbergMarquardt.h.

permutation

template<typename FunctorType_ >

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

Definition at line 111 of file NonLinearOptimization/LevenbergMarquardt.h.

pnorm

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::pnorm

private

Definition at line 130 of file NonLinearOptimization/LevenbergMarquardt.h.

prered

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::prered

private

Definition at line 130 of file NonLinearOptimization/LevenbergMarquardt.h.

qtf

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::qtf

Definition at line 109 of file NonLinearOptimization/LevenbergMarquardt.h.

ratio

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::ratio

private

Definition at line 129 of file NonLinearOptimization/LevenbergMarquardt.h.

sum

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::sum

private

Definition at line 126 of file NonLinearOptimization/LevenbergMarquardt.h.

temp

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::temp

private

Definition at line 127 of file NonLinearOptimization/LevenbergMarquardt.h.

temp1

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::temp1

private

Definition at line 127 of file NonLinearOptimization/LevenbergMarquardt.h.

temp2

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::temp2

private

Definition at line 127 of file NonLinearOptimization/LevenbergMarquardt.h.

useExternalScaling

template<typename FunctorType_ >

bool Eigen::LevenbergMarquardt< FunctorType_ >::useExternalScaling

Definition at line 116 of file NonLinearOptimization/LevenbergMarquardt.h.

wa1

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::wa1

private

Definition at line 124 of file NonLinearOptimization/LevenbergMarquardt.h.

wa2

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::wa2

private

Definition at line 124 of file NonLinearOptimization/LevenbergMarquardt.h.

wa3

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::wa3

private

Definition at line 124 of file NonLinearOptimization/LevenbergMarquardt.h.

wa4

template<typename FunctorType_ >

FVectorType Eigen::LevenbergMarquardt< FunctorType_ >::wa4

private

Definition at line 124 of file NonLinearOptimization/LevenbergMarquardt.h.

xnorm

template<typename FunctorType_ >

Scalar Eigen::LevenbergMarquardt< FunctorType_ >::xnorm

private

Definition at line 130 of file NonLinearOptimization/LevenbergMarquardt.h.

---

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

• LevenbergMarquardt/LevenbergMarquardt.h
• LMonestep.h