|
| | RootFinder () |
| constexpr std::string | name () const |
| Integer | jacobian_evaluations () const |
| Integer | max_jacobian_evaluations () const |
| void | max_jacobian_evaluations (const Integer t_jacobian_evaluations) |
| Integer | hessian_evaluations () const |
| Integer | max_hessian_evaluations () const |
| void | max_hessian_evaluations (const Integer t_hessian_evaluations) |
| template<typename FunctionLambda> |
| bool | solve (FunctionLambda &&function, const Input &x_ini, Output &x_sol) |
| template<typename FunctionLambda, typename JacobianLambda> |
| bool | solve (FunctionLambda &&function, JacobianLambda &&jacobian, const Input &x_ini, Output &x_sol) |
| template<typename FunctionLambda, typename JacobianLambda, typename HessianLambda> |
| bool | solve (FunctionLambda &&function, JacobianLambda &&jacobian, HessianLambda &&hessian, const Input &x_ini, Output &x_sol) |
| | SolverBase () |
| void | reset_bounds (const Integer n=InputTrait::IsDynamic ? 0 :InputTrait::Dimension) |
| const T & | lower_bound () const |
| const T & | upper_bound () const |
| void | bounds (const T &t_lower_bound, const T &t_upper_bound) |
| constexpr Integer | input_dimension () const |
| constexpr Integer | output_dimension () const |
| Integer | function_evaluations () const |
| void | max_function_evaluations (const Integer t_max_function_evaluations) |
| Integer | iterations () const |
| Integer | max_iterations () const |
| Scalar | alpha () const |
| Integer | relaxations () const |
| Integer | max_relaxations () const |
| Scalar | tolerance () const |
| void | verbose_mode (bool t_verbose) |
| void | enable_verbose_mode () |
| void | disable_verbose_mode () |
| void | damped_mode (bool t_damped) |
| void | enable_damped_mode () |
| void | disable_damped_mode () |
| std::string | task () const |
| bool | converged () const |
| std::ostream & | ostream () const |
| bool | solve (FunctionLambda &&function, const T &x_ini, T &x_sol) |
| bool | rootfind (const FunctionBase< FunctionInput, FunctionOutput, DerivedFunction > &function, const T &x_ini, T &x_sol) |
| bool | optimize (const FunctionBase< FunctionInput, FunctionOutput, DerivedFunction > &function, const T &x_ini, T &x_sol) |
| constexpr std::string | name () const |
|
| template<typename JacobianLambda> |
| bool | evaluate_jacobian (JacobianLambda &&jacobian, const Input &x, FirstDerivative &out) |
| template<typename HessianLambda> |
| bool | evaluate_hessian (HessianLambda &&hessian, const Input &x, SecondDerivative &out) |
| Integer | first_derivative_evaluations () const |
| Integer | max_first_derivative_evaluations () const |
| Integer | second_derivative_evaluations () const |
| Integer | max_second_derivative_evaluations () const |
| void | reset_counters () |
| bool | evaluate_function (FunctionLambda &&function, const T &x, T &out) |
| bool | evaluate_first_derivative (FirstDerivativeLambda &&function, const T &x, FirstDerivative &out) |
| bool | evaluate_second_derivative (SecondDerivativeLambda &&function, const T &x, SecondDerivative &out) |
| bool | damp (FunctionLambda &&function, const T &x_old, const T &function_old, const T &step_old, T &x_new, T &function_new, T &step_new) |
| void | header () |
| void | bottom () |
| void | info (Scalar residuals, const std::string ¬es="-") |
template<typename T, typename DerivedSolver>
requires (
TypeTrait<T>::IsScalar ||
TypeTrait<T>::IsEigen) && (!
TypeTrait<T>::IsFixed ||
TypeTrait<T>::Dimension > 0)
class Optimist::RootFinder::RootFinder< T, DerivedSolver >
Root finder
This section describes the multi-dimensional root-finders implemented in Optimist. The available root-finding solvers are Newton (derivative) and quasi-Newton (non-derivative) methods. Derivative methods employ the function's derivative to find the root with high accuracy, while non-derivative methods approximate the derivative for improved efficiency in certain scenarios.
Here, the solvers are implemented for solving problems of the form
\[ \mathbf{f}(\mathbf{x}) = \mathbf{0} \text{,} \quad \text{with} \quad \mathbf{f}: \mathbb{R}^{n} \rightarrow \mathbb{R}^{n} \text{,}
\]
which consist in finding the root of the function \(\mathbf{f}\) by iteratively updating the current iterate \(\mathbf{x}_k\) until convergence is achieved. The solvers require the function \(\mathbf{f}\) and its Jacobian matrix \(\mathbf{Jf}_{\mathbf{x}}\) to be provided by the user. The Jacobian matrix can be computed analytically or numerically, depending on the problem's complexity and the user's preference. Alternatively, the Jacobian can be approximated numerically using finite differences, depending on the problem's complexity and the user's preference.
Affine-invariant step
By default, the multi-dimensional root-finders in Optimist use optionally an affine-invariant advancing step to ensure convergence. The generic advancing step \(\mathbf{h}_k\) is computed as
\[ \mathbf{x}_{k+1} = \mathbf{x}_k + \alpha_k \mathbf{h}_k \text{,}
\]
where \(\alpha_k\) is a damping coefficient that ensures convergence by satisfying
\[ \left\|\mathbf{Jf}_{\mathbf{x}}(\mathbf{x}_k)^{-1} \mathbf{f}(\mathbf{x}_{k+1})\right\|
\leq \left(1 - \displaystyle\frac{\alpha_k}{2}\right) \left\|\mathbf{Jf}_{\mathbf{x}}(\mathbf{x}_k)^{-1}
\mathbf{f}(\mathbf{x}_k)\right\| = \left(1 - \displaystyle\frac{\alpha_k}{2} \right)
\left\|\mathbf{h}_k\right\| \text{.}
\]
For detailed information on the affine-invariant Newton's method, refer to this link, or the works by P. Deuflhard.
- Template Parameters
-
| T | Input and output type (scalar or Eigen vector). |
| DerivedSolver | Derived solver class. |
1.16.1