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...

Classes
struct	Parameters

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

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

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

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

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

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.

Definition at line 45 of file HybridNonLinearSolver.h.

Member Typedef Documentation

FVectorType

template<typename FunctorType , typename Scalar = double>

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

Definition at line 68 of file HybridNonLinearSolver.h.

Index

template<typename FunctorType , typename Scalar = double>

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

Definition at line 48 of file HybridNonLinearSolver.h.

JacobianType

template<typename FunctorType , typename Scalar = double>

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

Definition at line 69 of file HybridNonLinearSolver.h.

UpperTriangularType

template<typename FunctorType , typename Scalar = double>

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

Definition at line 71 of file HybridNonLinearSolver.h.

Constructor & Destructor Documentation

HybridNonLinearSolver()

template<typename FunctorType , typename Scalar = double>

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

inline

Definition at line 50 of file HybridNonLinearSolver.h.

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

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

Definition at line 360 of file HybridNonLinearSolver.h.

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

hybrj1()

template<typename FunctorType , typename Scalar >

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

Definition at line 124 of file HybridNonLinearSolver.h.

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

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

Definition at line 91 of file HybridNonLinearSolver.h.

{ parameters = Parameters(); }

solve()

template<typename FunctorType , typename Scalar >

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

(

FVectorType &

x

)

Definition at line 346 of file HybridNonLinearSolver.h.

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

solveInit()

template<typename FunctorType , typename Scalar >

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

(

FVectorType &

x

)

Definition at line 145 of file HybridNonLinearSolver.h.

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

solveNumericalDiff()

template<typename FunctorType , typename Scalar >

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

(

FVectorType &

x

)

Definition at line 589 of file HybridNonLinearSolver.h.

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

solveNumericalDiffInit()

template<typename FunctorType , typename Scalar >

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

(

FVectorType &

x

)

Definition at line 382 of file HybridNonLinearSolver.h.

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

solveNumericalDiffOneStep()

template<typename FunctorType , typename Scalar >

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

(

FVectorType &

x

)

Definition at line 428 of file HybridNonLinearSolver.h.

{
    using std::sqrt;
    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;
    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;
}

solveOneStep()

template<typename FunctorType , typename Scalar >

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

(

FVectorType &

x

)

Definition at line 188 of file HybridNonLinearSolver.h.

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

Member Data Documentation

actred

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 114 of file HybridNonLinearSolver.h.

delta

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 107 of file HybridNonLinearSolver.h.

diag

template<typename FunctorType , typename Scalar = double>

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

Definition at line 93 of file HybridNonLinearSolver.h.

fjac

template<typename FunctorType , typename Scalar = double>

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

Definition at line 94 of file HybridNonLinearSolver.h.

fnorm

template<typename FunctorType , typename Scalar = double>

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

Definition at line 99 of file HybridNonLinearSolver.h.

fnorm1

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 111 of file HybridNonLinearSolver.h.

functor

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 102 of file HybridNonLinearSolver.h.

fvec

template<typename FunctorType , typename Scalar = double>

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

Definition at line 93 of file HybridNonLinearSolver.h.

iter

template<typename FunctorType , typename Scalar = double>

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

Definition at line 98 of file HybridNonLinearSolver.h.

jeval

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 108 of file HybridNonLinearSolver.h.

n

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 103 of file HybridNonLinearSolver.h.

ncfail

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 113 of file HybridNonLinearSolver.h.

ncsuc

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 109 of file HybridNonLinearSolver.h.

nfev

template<typename FunctorType , typename Scalar = double>

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

Definition at line 96 of file HybridNonLinearSolver.h.

njev

template<typename FunctorType , typename Scalar = double>

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

Definition at line 97 of file HybridNonLinearSolver.h.

nslow1

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 112 of file HybridNonLinearSolver.h.

nslow2

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 112 of file HybridNonLinearSolver.h.

parameters

template<typename FunctorType , typename Scalar = double>

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

Definition at line 92 of file HybridNonLinearSolver.h.

pnorm

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 111 of file HybridNonLinearSolver.h.

prered

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 114 of file HybridNonLinearSolver.h.

qtf

template<typename FunctorType , typename Scalar = double>

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

Definition at line 93 of file HybridNonLinearSolver.h.

R

template<typename FunctorType , typename Scalar = double>

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

Definition at line 95 of file HybridNonLinearSolver.h.

ratio

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 110 of file HybridNonLinearSolver.h.

sing

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 105 of file HybridNonLinearSolver.h.

sum

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 104 of file HybridNonLinearSolver.h.

temp

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 106 of file HybridNonLinearSolver.h.

useExternalScaling

template<typename FunctorType , typename Scalar = double>

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

Definition at line 100 of file HybridNonLinearSolver.h.

wa1

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 115 of file HybridNonLinearSolver.h.

wa2

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 115 of file HybridNonLinearSolver.h.

wa3

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 115 of file HybridNonLinearSolver.h.

wa4

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 115 of file HybridNonLinearSolver.h.

xnorm

template<typename FunctorType , typename Scalar = double>

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

private

Definition at line 111 of file HybridNonLinearSolver.h.

---

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

• HybridNonLinearSolver.h