Eigen::HybridNonLinearSolver< FunctorType, Scalar > Class Template Reference

Finds a zero of a system of n nonlinear functions in n variables by a modification of the Powell hybrid method ("dogleg"). More...

#include <HybridNonLinearSolver.h>

Classes
struct	Parameters

Public Types
typedef DenseIndex	Index
typedef Matrix< Scalar, Dynamic, 1 >	FVectorType
typedef Matrix< Scalar, Dynamic, Dynamic >	JacobianType
typedef Matrix< Scalar, Dynamic, Dynamic >	UpperTriangularType

Public Member Functions
	HybridNonLinearSolver (FunctorType &_functor)
HybridNonLinearSolverSpace::Status	hybrj1 (FVectorType &x, const Scalar tol=numext::sqrt(NumTraits< Scalar >::epsilon()))
HybridNonLinearSolverSpace::Status	solveInit (FVectorType &x)
HybridNonLinearSolverSpace::Status	solveOneStep (FVectorType &x)
HybridNonLinearSolverSpace::Status	solve (FVectorType &x)
HybridNonLinearSolverSpace::Status	hybrd1 (FVectorType &x, const Scalar tol=numext::sqrt(NumTraits< Scalar >::epsilon()))
HybridNonLinearSolverSpace::Status	solveNumericalDiffInit (FVectorType &x)
HybridNonLinearSolverSpace::Status	solveNumericalDiffOneStep (FVectorType &x)
HybridNonLinearSolverSpace::Status	solveNumericalDiff (FVectorType &x)
void	resetParameters (void)

Public Attributes
Parameters	parameters
FVectorType	fvec
FVectorType	qtf
FVectorType	diag
JacobianType	fjac
UpperTriangularType	R
Index	nfev
Index	njev
Index	iter
Scalar	fnorm
bool	useExternalScaling

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

Private Attributes
FunctorType &	functor
Index	n
Scalar	sum
bool	sing
Scalar	temp
Scalar	delta
bool	jeval
Index	ncsuc
Scalar	ratio
Scalar	pnorm
Scalar	xnorm
Scalar	fnorm1
Index	nslow1
Index	nslow2
Index	ncfail
Scalar	actred
Scalar	prered
FVectorType	wa1
FVectorType	wa2
FVectorType	wa3
FVectorType	wa4

Detailed Description

template<typename FunctorType, typename Scalar = double>
class Eigen::HybridNonLinearSolver< FunctorType, Scalar >

Finds a zero of a system of n nonlinear functions in n variables by a modification of the Powell hybrid method ("dogleg").

The user must provide a subroutine which calculates the functions. The Jacobian is either provided by the user, or approximated using a forward-difference method.

Member Typedef Documentation

FVectorType

template<typename FunctorType , typename Scalar = double>

typedef Matrix<Scalar, Dynamic, 1> Eigen::HybridNonLinearSolver< FunctorType, Scalar >::FVectorType

Index

template<typename FunctorType , typename Scalar = double>

typedef DenseIndex Eigen::HybridNonLinearSolver< FunctorType, Scalar >::Index

JacobianType

template<typename FunctorType , typename Scalar = double>

typedef Matrix<Scalar, Dynamic, Dynamic> Eigen::HybridNonLinearSolver< FunctorType, Scalar >::JacobianType

UpperTriangularType

template<typename FunctorType , typename Scalar = double>

typedef Matrix<Scalar, Dynamic, Dynamic> Eigen::HybridNonLinearSolver< FunctorType, Scalar >::UpperTriangularType

Constructor & Destructor Documentation

HybridNonLinearSolver()

template<typename FunctorType , typename Scalar = double>

Eigen::HybridNonLinearSolver< FunctorType, Scalar >::HybridNonLinearSolver ( FunctorType &  _functor )

inline

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

References Eigen::HybridNonLinearSolver< FunctorType, Scalar >::fnorm, Eigen::HybridNonLinearSolver< FunctorType, Scalar >::iter, Eigen::HybridNonLinearSolver< FunctorType, Scalar >::nfev, Eigen::HybridNonLinearSolver< FunctorType, Scalar >::njev, and Eigen::HybridNonLinearSolver< FunctorType, Scalar >::useExternalScaling.

Member Function Documentation

hybrd1()

template<typename FunctorType , typename Scalar >

HybridNonLinearSolverSpace::Status Eigen::HybridNonLinearSolver< FunctorType, Scalar >::hybrd1	(	FVectorType &	x,
		const Scalar	tol = numext::sqrt(NumTraits<Scalar>::epsilon())
	)

                                                                                                        {
  n = x.size();
 
  /* check the input parameters for errors. */
  if (n <= 0 || tol < 0.) return HybridNonLinearSolverSpace::ImproperInputParameters;
 
  resetParameters();
  parameters.maxfev = 200 * (n + 1);
  parameters.xtol = tol;
 
  diag.setConstant(n, 1.);
  useExternalScaling = true;
  return solveNumericalDiff(x);
}

References diag, Eigen::HybridNonLinearSolverSpace::ImproperInputParameters, n, and plotDoE::x.

hybrj1()

template<typename FunctorType , typename Scalar >

HybridNonLinearSolverSpace::Status Eigen::HybridNonLinearSolver< FunctorType, Scalar >::hybrj1	(	FVectorType &	x,
		const Scalar	tol = numext::sqrt(NumTraits<Scalar>::epsilon())
	)

                                                                                                        {
  n = x.size();
 
  /* check the input parameters for errors. */
  if (n <= 0 || tol < 0.) return HybridNonLinearSolverSpace::ImproperInputParameters;
 
  resetParameters();
  parameters.maxfev = 100 * (n + 1);
  parameters.xtol = tol;
  diag.setConstant(n, 1.);
  useExternalScaling = true;
  return solve(x);
}

References diag, Eigen::HybridNonLinearSolverSpace::ImproperInputParameters, n, solve, and plotDoE::x.

operator=()

template<typename FunctorType , typename Scalar = double>

HybridNonLinearSolver& Eigen::HybridNonLinearSolver< FunctorType, Scalar >::operator= ( const HybridNonLinearSolver< FunctorType, Scalar > &  )

private

resetParameters()

template<typename FunctorType , typename Scalar = double>

void Eigen::HybridNonLinearSolver< FunctorType, Scalar >::resetParameters ( void  )

inline

{ parameters = Parameters(); }

References Eigen::HybridNonLinearSolver< FunctorType, Scalar >::parameters.

solve()

template<typename FunctorType , typename Scalar >

HybridNonLinearSolverSpace::Status Eigen::HybridNonLinearSolver< FunctorType, Scalar >::solve

(

FVectorType &

x

)

                                                                                                 {
  HybridNonLinearSolverSpace::Status status = solveInit(x);
  if (status == HybridNonLinearSolverSpace::ImproperInputParameters) return status;
  while (status == HybridNonLinearSolverSpace::Running) status = solveOneStep(x);
  return status;
}

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

solveInit()

template<typename FunctorType , typename Scalar >

HybridNonLinearSolverSpace::Status Eigen::HybridNonLinearSolver< FunctorType, Scalar >::solveInit

(

FVectorType &

x

)

                                                                                                     {
  n = x.size();
 
  wa1.resize(n);
  wa2.resize(n);
  wa3.resize(n);
  wa4.resize(n);
  fvec.resize(n);
  qtf.resize(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'");
 
  /* Function Body */
  nfev = 0;
  njev = 0;
 
  /*     check the input parameters for errors. */
  if (n <= 0 || parameters.xtol < 0. || parameters.maxfev <= 0 || parameters.factor <= 0.)
    return HybridNonLinearSolverSpace::ImproperInputParameters;
  if (useExternalScaling)
    for (Index j = 0; j < n; ++j)
      if (diag[j] <= 0.) return HybridNonLinearSolverSpace::ImproperInputParameters;
 
  /*     evaluate the function at the starting point */
  /*     and calculate its norm. */
  nfev = 1;
  if (functor(x, fvec) < 0) return HybridNonLinearSolverSpace::UserAsked;
  fnorm = fvec.stableNorm();
 
  /*     initialize iteration counter and monitors. */
  iter = 1;
  ncsuc = 0;
  ncfail = 0;
  nslow1 = 0;
  nslow2 = 0;
 
  return HybridNonLinearSolverSpace::Running;
}

References diag, eigen_assert, Eigen::HybridNonLinearSolverSpace::ImproperInputParameters, j, n, Eigen::HybridNonLinearSolverSpace::Running, Eigen::HybridNonLinearSolverSpace::UserAsked, and plotDoE::x.

solveNumericalDiff()

template<typename FunctorType , typename Scalar >

HybridNonLinearSolverSpace::Status Eigen::HybridNonLinearSolver< FunctorType, Scalar >::solveNumericalDiff

(

FVectorType &

x

)

                                                                                                              {
  HybridNonLinearSolverSpace::Status status = solveNumericalDiffInit(x);
  if (status == HybridNonLinearSolverSpace::ImproperInputParameters) return status;
  while (status == HybridNonLinearSolverSpace::Running) status = solveNumericalDiffOneStep(x);
  return status;
}

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

solveNumericalDiffInit()

template<typename FunctorType , typename Scalar >

HybridNonLinearSolverSpace::Status Eigen::HybridNonLinearSolver< FunctorType, Scalar >::solveNumericalDiffInit

(

FVectorType &

x

)

                                                                                                                  {
  n = x.size();
 
  if (parameters.nb_of_subdiagonals < 0) parameters.nb_of_subdiagonals = n - 1;
  if (parameters.nb_of_superdiagonals < 0) parameters.nb_of_superdiagonals = n - 1;
 
  wa1.resize(n);
  wa2.resize(n);
  wa3.resize(n);
  wa4.resize(n);
  qtf.resize(n);
  fjac.resize(n, n);
  fvec.resize(n);
  if (!useExternalScaling) diag.resize(n);
  eigen_assert((!useExternalScaling || diag.size() == n) &&
               "When useExternalScaling is set, the caller must provide a valid 'diag'");
 
  /* Function Body */
  nfev = 0;
  njev = 0;
 
  /*     check the input parameters for errors. */
  if (n <= 0 || parameters.xtol < 0. || parameters.maxfev <= 0 || parameters.nb_of_subdiagonals < 0 ||
      parameters.nb_of_superdiagonals < 0 || parameters.factor <= 0.)
    return HybridNonLinearSolverSpace::ImproperInputParameters;
  if (useExternalScaling)
    for (Index j = 0; j < n; ++j)
      if (diag[j] <= 0.) return HybridNonLinearSolverSpace::ImproperInputParameters;
 
  /*     evaluate the function at the starting point */
  /*     and calculate its norm. */
  nfev = 1;
  if (functor(x, fvec) < 0) return HybridNonLinearSolverSpace::UserAsked;
  fnorm = fvec.stableNorm();
 
  /*     initialize iteration counter and monitors. */
  iter = 1;
  ncsuc = 0;
  ncfail = 0;
  nslow1 = 0;
  nslow2 = 0;
 
  return HybridNonLinearSolverSpace::Running;
}

References diag, eigen_assert, Eigen::HybridNonLinearSolverSpace::ImproperInputParameters, j, n, Eigen::HybridNonLinearSolverSpace::Running, Eigen::HybridNonLinearSolverSpace::UserAsked, and plotDoE::x.

solveNumericalDiffOneStep()

template<typename FunctorType , typename Scalar >

HybridNonLinearSolverSpace::Status Eigen::HybridNonLinearSolver< FunctorType, Scalar >::solveNumericalDiffOneStep

(

FVectorType &

x

)

                    {
  using std::abs;
  using std::sqrt;
 
  eigen_assert(x.size() == n);  // check the caller is not cheating us
 
  Index j;
  std::vector<JacobiRotation<Scalar> > v_givens(n), w_givens(n);
 
  jeval = true;
  if (parameters.nb_of_subdiagonals < 0) parameters.nb_of_subdiagonals = n - 1;
  if (parameters.nb_of_superdiagonals < 0) parameters.nb_of_superdiagonals = n - 1;
 
  /* calculate the jacobian matrix. */
  if (internal::fdjac1(functor, x, fvec, fjac, parameters.nb_of_subdiagonals, parameters.nb_of_superdiagonals,
                       parameters.epsfcn) < 0)
    return HybridNonLinearSolverSpace::UserAsked;
  nfev += (std::min)(parameters.nb_of_subdiagonals + parameters.nb_of_superdiagonals + 1, n);
 
  wa2 = fjac.colwise().blueNorm();
 
  /* 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 qr factorization of the jacobian. */
  HouseholderQR<JacobianType> qrfac(fjac);  // no pivoting:
 
  /* copy the triangular factor of the qr factorization into r. */
  R = qrfac.matrixQR();
 
  /* accumulate the orthogonal factor in fjac. */
  fjac = qrfac.householderQ();
 
  /* form (q transpose)*fvec and store in qtf. */
  qtf = fjac.transpose() * fvec;
 
  /* rescale if necessary. */
  if (!useExternalScaling) diag = diag.cwiseMax(wa2);
 
  while (true) {
    /* determine the direction p. */
    internal::dogleg<Scalar>(R, diag, qtf, delta, 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 HybridNonLinearSolverSpace::UserAsked;
    ++nfev;
    fnorm1 = wa4.stableNorm();
 
    /* compute the scaled actual reduction. */
    actred = -1.;
    if (fnorm1 < fnorm) /* Computing 2nd power */
      actred = 1. - numext::abs2(fnorm1 / fnorm);
 
    /* compute the scaled predicted reduction. */
    wa3 = R.template triangularView<Upper>() * wa1 + qtf;
    temp = wa3.stableNorm();
    prered = 0.;
    if (temp < fnorm) /* Computing 2nd power */
      prered = 1. - numext::abs2(temp / fnorm);
 
    /* 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(.1)) {
      ncsuc = 0;
      ++ncfail;
      delta = Scalar(.5) * delta;
    } else {
      ncfail = 0;
      ++ncsuc;
      if (ratio >= Scalar(.5) || ncsuc > 1) delta = (std::max)(delta, pnorm / Scalar(.5));
      if (abs(ratio - 1.) <= Scalar(.1)) {
        delta = pnorm / Scalar(.5);
      }
    }
 
    /* 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;
    }
 
    /* determine the progress of the iteration. */
    ++nslow1;
    if (actred >= Scalar(.001)) nslow1 = 0;
    if (jeval) ++nslow2;
    if (actred >= Scalar(.1)) nslow2 = 0;
 
    /* test for convergence. */
    if (delta <= parameters.xtol * xnorm || fnorm == 0.) return HybridNonLinearSolverSpace::RelativeErrorTooSmall;
 
    /* tests for termination and stringent tolerances. */
    if (nfev >= parameters.maxfev) return HybridNonLinearSolverSpace::TooManyFunctionEvaluation;
    if (Scalar(.1) * (std::max)(Scalar(.1) * delta, pnorm) <= NumTraits<Scalar>::epsilon() * xnorm)
      return HybridNonLinearSolverSpace::TolTooSmall;
    if (nslow2 == 5) return HybridNonLinearSolverSpace::NotMakingProgressJacobian;
    if (nslow1 == 10) return HybridNonLinearSolverSpace::NotMakingProgressIterations;
 
    /* criterion for recalculating jacobian. */
    if (ncfail == 2) break;  // leave inner loop and go for the next outer loop iteration
 
    /* calculate the rank one modification to the jacobian */
    /* and update qtf if necessary. */
    wa1 = diag.cwiseProduct(diag.cwiseProduct(wa1) / pnorm);
    wa2 = fjac.transpose() * wa4;
    if (ratio >= Scalar(1e-4)) qtf = wa2;
    wa2 = (wa2 - wa3) / pnorm;
 
    /* compute the qr factorization of the updated jacobian. */
    internal::r1updt<Scalar>(R, wa1, v_givens, w_givens, wa2, wa3, &sing);
    internal::r1mpyq<Scalar>(n, n, fjac.data(), v_givens, w_givens);
    internal::r1mpyq<Scalar>(1, n, qtf.data(), v_givens, w_givens);
 
    jeval = false;
  }
  return HybridNonLinearSolverSpace::Running;
}

References abs(), Eigen::numext::abs2(), MultiOpt::delta, diag, e(), eigen_assert, Eigen::internal::fdjac1(), Eigen::HouseholderQR< MatrixType_ >::householderQ(), j, Eigen::HouseholderQR< MatrixType_ >::matrixQR(), max, min, n, Eigen::HybridNonLinearSolverSpace::NotMakingProgressIterations, Eigen::HybridNonLinearSolverSpace::NotMakingProgressJacobian, R, Eigen::HybridNonLinearSolverSpace::RelativeErrorTooSmall, Eigen::HybridNonLinearSolverSpace::Running, sqrt(), Eigen::HybridNonLinearSolverSpace::TolTooSmall, Eigen::HybridNonLinearSolverSpace::TooManyFunctionEvaluation, Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::transpose(), Eigen::HybridNonLinearSolverSpace::UserAsked, and plotDoE::x.

solveOneStep()

template<typename FunctorType , typename Scalar >

HybridNonLinearSolverSpace::Status Eigen::HybridNonLinearSolver< FunctorType, Scalar >::solveOneStep

(

FVectorType &

x

)

                                                                                                        {
  using std::abs;
 
  eigen_assert(x.size() == n);  // check the caller is not cheating us
 
  Index j;
  std::vector<JacobiRotation<Scalar> > v_givens(n), w_givens(n);
 
  jeval = true;
 
  /* calculate the jacobian matrix. */
  if (functor.df(x, fjac) < 0) return HybridNonLinearSolverSpace::UserAsked;
  ++njev;
 
  wa2 = fjac.colwise().blueNorm();
 
  /* 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 qr factorization of the jacobian. */
  HouseholderQR<JacobianType> qrfac(fjac);  // no pivoting:
 
  /* copy the triangular factor of the qr factorization into r. */
  R = qrfac.matrixQR();
 
  /* accumulate the orthogonal factor in fjac. */
  fjac = qrfac.householderQ();
 
  /* form (q transpose)*fvec and store in qtf. */
  qtf = fjac.transpose() * fvec;
 
  /* rescale if necessary. */
  if (!useExternalScaling) diag = diag.cwiseMax(wa2);
 
  while (true) {
    /* determine the direction p. */
    internal::dogleg<Scalar>(R, diag, qtf, delta, 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 HybridNonLinearSolverSpace::UserAsked;
    ++nfev;
    fnorm1 = wa4.stableNorm();
 
    /* compute the scaled actual reduction. */
    actred = -1.;
    if (fnorm1 < fnorm) /* Computing 2nd power */
      actred = 1. - numext::abs2(fnorm1 / fnorm);
 
    /* compute the scaled predicted reduction. */
    wa3 = R.template triangularView<Upper>() * wa1 + qtf;
    temp = wa3.stableNorm();
    prered = 0.;
    if (temp < fnorm) /* Computing 2nd power */
      prered = 1. - numext::abs2(temp / fnorm);
 
    /* 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(.1)) {
      ncsuc = 0;
      ++ncfail;
      delta = Scalar(.5) * delta;
    } else {
      ncfail = 0;
      ++ncsuc;
      if (ratio >= Scalar(.5) || ncsuc > 1) delta = (std::max)(delta, pnorm / Scalar(.5));
      if (abs(ratio - 1.) <= Scalar(.1)) {
        delta = pnorm / Scalar(.5);
      }
    }
 
    /* 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;
    }
 
    /* determine the progress of the iteration. */
    ++nslow1;
    if (actred >= Scalar(.001)) nslow1 = 0;
    if (jeval) ++nslow2;
    if (actred >= Scalar(.1)) nslow2 = 0;
 
    /* test for convergence. */
    if (delta <= parameters.xtol * xnorm || fnorm == 0.) return HybridNonLinearSolverSpace::RelativeErrorTooSmall;
 
    /* tests for termination and stringent tolerances. */
    if (nfev >= parameters.maxfev) return HybridNonLinearSolverSpace::TooManyFunctionEvaluation;
    if (Scalar(.1) * (std::max)(Scalar(.1) * delta, pnorm) <= NumTraits<Scalar>::epsilon() * xnorm)
      return HybridNonLinearSolverSpace::TolTooSmall;
    if (nslow2 == 5) return HybridNonLinearSolverSpace::NotMakingProgressJacobian;
    if (nslow1 == 10) return HybridNonLinearSolverSpace::NotMakingProgressIterations;
 
    /* criterion for recalculating jacobian. */
    if (ncfail == 2) break;  // leave inner loop and go for the next outer loop iteration
 
    /* calculate the rank one modification to the jacobian */
    /* and update qtf if necessary. */
    wa1 = diag.cwiseProduct(diag.cwiseProduct(wa1) / pnorm);
    wa2 = fjac.transpose() * wa4;
    if (ratio >= Scalar(1e-4)) qtf = wa2;
    wa2 = (wa2 - wa3) / pnorm;
 
    /* compute the qr factorization of the updated jacobian. */
    internal::r1updt<Scalar>(R, wa1, v_givens, w_givens, wa2, wa3, &sing);
    internal::r1mpyq<Scalar>(n, n, fjac.data(), v_givens, w_givens);
    internal::r1mpyq<Scalar>(1, n, qtf.data(), v_givens, w_givens);
 
    jeval = false;
  }
  return HybridNonLinearSolverSpace::Running;
}

References abs(), Eigen::numext::abs2(), MultiOpt::delta, diag, e(), eigen_assert, Eigen::HouseholderQR< MatrixType_ >::householderQ(), j, Eigen::HouseholderQR< MatrixType_ >::matrixQR(), max, min, n, Eigen::HybridNonLinearSolverSpace::NotMakingProgressIterations, Eigen::HybridNonLinearSolverSpace::NotMakingProgressJacobian, R, Eigen::HybridNonLinearSolverSpace::RelativeErrorTooSmall, Eigen::HybridNonLinearSolverSpace::Running, Eigen::HybridNonLinearSolverSpace::TolTooSmall, Eigen::HybridNonLinearSolverSpace::TooManyFunctionEvaluation, Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::transpose(), Eigen::HybridNonLinearSolverSpace::UserAsked, and plotDoE::x.

Member Data Documentation

actred

template<typename FunctorType , typename Scalar = double>

Scalar Eigen::HybridNonLinearSolver< FunctorType, Scalar >::actred

private

delta

template<typename FunctorType , typename Scalar = double>

Scalar Eigen::HybridNonLinearSolver< FunctorType, Scalar >::delta

private

diag

template<typename FunctorType , typename Scalar = double>

FVectorType Eigen::HybridNonLinearSolver< FunctorType, Scalar >::diag

fjac

template<typename FunctorType , typename Scalar = double>

JacobianType Eigen::HybridNonLinearSolver< FunctorType, Scalar >::fjac

fnorm

template<typename FunctorType , typename Scalar = double>

Scalar Eigen::HybridNonLinearSolver< FunctorType, Scalar >::fnorm

Referenced by Eigen::HybridNonLinearSolver< FunctorType, Scalar >::HybridNonLinearSolver().

fnorm1

template<typename FunctorType , typename Scalar = double>

Scalar Eigen::HybridNonLinearSolver< FunctorType, Scalar >::fnorm1

private

functor

template<typename FunctorType , typename Scalar = double>

FunctorType& Eigen::HybridNonLinearSolver< FunctorType, Scalar >::functor

private

fvec

template<typename FunctorType , typename Scalar = double>

FVectorType Eigen::HybridNonLinearSolver< FunctorType, Scalar >::fvec

iter

template<typename FunctorType , typename Scalar = double>

Index Eigen::HybridNonLinearSolver< FunctorType, Scalar >::iter

Referenced by Eigen::HybridNonLinearSolver< FunctorType, Scalar >::HybridNonLinearSolver().

jeval

template<typename FunctorType , typename Scalar = double>

bool Eigen::HybridNonLinearSolver< FunctorType, Scalar >::jeval

private

n

template<typename FunctorType , typename Scalar = double>

Index Eigen::HybridNonLinearSolver< FunctorType, Scalar >::n

private

ncfail

template<typename FunctorType , typename Scalar = double>

Index Eigen::HybridNonLinearSolver< FunctorType, Scalar >::ncfail

private

ncsuc

template<typename FunctorType , typename Scalar = double>

Index Eigen::HybridNonLinearSolver< FunctorType, Scalar >::ncsuc

private

nfev

template<typename FunctorType , typename Scalar = double>

Index Eigen::HybridNonLinearSolver< FunctorType, Scalar >::nfev

Referenced by Eigen::HybridNonLinearSolver< FunctorType, Scalar >::HybridNonLinearSolver().

njev

template<typename FunctorType , typename Scalar = double>

Index Eigen::HybridNonLinearSolver< FunctorType, Scalar >::njev

Referenced by Eigen::HybridNonLinearSolver< FunctorType, Scalar >::HybridNonLinearSolver().

nslow1

template<typename FunctorType , typename Scalar = double>

Index Eigen::HybridNonLinearSolver< FunctorType, Scalar >::nslow1

private

nslow2

template<typename FunctorType , typename Scalar = double>

Index Eigen::HybridNonLinearSolver< FunctorType, Scalar >::nslow2

private

parameters

template<typename FunctorType , typename Scalar = double>

Parameters Eigen::HybridNonLinearSolver< FunctorType, Scalar >::parameters

Referenced by Eigen::HybridNonLinearSolver< FunctorType, Scalar >::resetParameters().

pnorm

template<typename FunctorType , typename Scalar = double>

Scalar Eigen::HybridNonLinearSolver< FunctorType, Scalar >::pnorm

private

prered

template<typename FunctorType , typename Scalar = double>

Scalar Eigen::HybridNonLinearSolver< FunctorType, Scalar >::prered

private

qtf

template<typename FunctorType , typename Scalar = double>

FVectorType Eigen::HybridNonLinearSolver< FunctorType, Scalar >::qtf

R

template<typename FunctorType , typename Scalar = double>

UpperTriangularType Eigen::HybridNonLinearSolver< FunctorType, Scalar >::R

ratio

template<typename FunctorType , typename Scalar = double>

Scalar Eigen::HybridNonLinearSolver< FunctorType, Scalar >::ratio

private

sing

template<typename FunctorType , typename Scalar = double>

bool Eigen::HybridNonLinearSolver< FunctorType, Scalar >::sing

private

sum

template<typename FunctorType , typename Scalar = double>

Scalar Eigen::HybridNonLinearSolver< FunctorType, Scalar >::sum

private

temp

template<typename FunctorType , typename Scalar = double>

Scalar Eigen::HybridNonLinearSolver< FunctorType, Scalar >::temp

private

useExternalScaling

template<typename FunctorType , typename Scalar = double>

bool Eigen::HybridNonLinearSolver< FunctorType, Scalar >::useExternalScaling

Referenced by Eigen::HybridNonLinearSolver< FunctorType, Scalar >::HybridNonLinearSolver().

wa1

template<typename FunctorType , typename Scalar = double>

FVectorType Eigen::HybridNonLinearSolver< FunctorType, Scalar >::wa1

private

wa2

template<typename FunctorType , typename Scalar = double>

FVectorType Eigen::HybridNonLinearSolver< FunctorType, Scalar >::wa2

private

wa3

template<typename FunctorType , typename Scalar = double>

FVectorType Eigen::HybridNonLinearSolver< FunctorType, Scalar >::wa3

private

wa4

template<typename FunctorType , typename Scalar = double>

FVectorType Eigen::HybridNonLinearSolver< FunctorType, Scalar >::wa4

private

xnorm

template<typename FunctorType , typename Scalar = double>

Scalar Eigen::HybridNonLinearSolver< FunctorType, Scalar >::xnorm

private

---

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

• HybridNonLinearSolver.h