snls_control_type structure#

    struct snls_control_type{T,INT}
      f_indexing::Bool
      error::INT
      out::INT
      print_level::INT
      start_print::INT
      stop_print::INT
      print_gap::INT
      maxit::INT
      alive_unit::INT
      alive_file::NTuple{31,Cchar}
      jacobian_available::INT
      subproblem_solver::INT
      non_monotone::INT
      weight_update_strategy::INT
      stop_r_absolute::T
      stop_r_relative::T
      stop_pg_absolute::T
      stop_pg_relative::T
      stop_s::T
      stop_pg_switch::T
      initial_weight::T
      minimum_weight::T
      eta_successful::T
      eta_very_successful::T
      eta_too_successful::T
      weight_decrease_min::T
      weight_decrease::T
      weight_increase::T
      weight_increase_max::T
      switch_to_newton::T
      cpu_time_limit::T
      clock_time_limit::T
      newton_acceleration::Bool
      magic_step::Bool
      print_obj::Bool
      space_critical::Bool
      deallocate_error_fatal::Bool
      prefix::NTuple{31,Cchar}
      slls_control::slls_control_type{T,INT}
      sllsb_control::sllsb_control_type{T,INT}

detailed documentation#

control derived type as a Julia structure

components#

Bool f_indexing

use C or Fortran sparse matrix indexing

INT error

error and warning diagnostics occur on stream error

INT out

general output occurs on stream out

INT print_level

the level of output required.

$\leq$ 0 gives no output,
= 1 gives a one-line summary for every iteration,
= 2 gives a summary of the inner iteration for each iteration,
$\geq$ 3 gives increasingly verbose (debugging) output

INT start_print

any printing will start on this iteration

INT stop_print

any printing will stop on this iteration

INT print_gap

the number of iterations between printing

INT maxit

the maximum number of iterations performed

INT alive_unit

removal of the file alive_file from unit alive_unit terminates execution

char alive_file[31]

see alive_unit

INT jacobian_available

is the Jacobian matrix of first derivatives available ($\geq$ 2), is access only via matrix-vector products (=1) or is it not available ($\leq$ 0) ?

INT subproblem_solver

the method used to solve the crucial step-determination subproblem. Possible values are

1 a projected-gradient method using GALAHAD’s slls will be used
2 an interior-point method using GALAHAD’s sllsb will be used
3 an interior-point method will initially be used, but a switch to a projected-gradient method will occur when sufficient progress has occurred (see .stop_pg_switch).

INT non_monotone

non-monotone $\leq$ 0 monotone strategy used, anything else non-monotone strategy with this history length used

INT weight_update_strategy

define the weight-update strategy: 1 (basic), 2 (reset to zero when very successful), 3 (imitate TR), 4 (increase lower bound), 5 (GPT)

T stop_r_absolute

overall convergence tolerances. The iteration will terminate when $||r(x)||_2 \leq$ MAX( .stop_r_absolute, .stop_r_relative $* \|r(x_0)\|_2$ or when the norm of the gradient, $g(x) = J^T(x) W r(x)$ satisfies $\|P[x-g(x)]-x\|_2 \leq$ MAX( .stop_pg_absolute, .stop_pg_relative $* \|P[x_0-g(x_0)]-x_0\|_2$ or if the norm of step is less than .stop_s, where $x_0$ is the initial point.

T stop_r_relative

see stop_r_absolute

T stop_pg_absolute

see stop_r_absolute

T stop_pg_relative

see stop_r_absolute

T stop_s

see stop_r_absolute

T stop_pg_switch

the step-computation solver will switch from an interior-point method to a projected-gradient one if .subproblem_solver = 3 (see above) and $\|P[x-g(x)]-x\|_2 \leq$ MAX( .stop_pg_absolute, .stop_pg_switch $* \|P[x_0-g(x_0)]-x_0\|_2.

T initial_weight

initial value for the regularization weight (-ve => $1/\|g_0\|)$)

T minimum_weight

minimum permitted regularization weight

T eta_successful

a potential iterate will only be accepted if the actual decrease f - f(x_new) is larger than .eta_successful times that predicted by a quadratic model of the decrease. The regularization weight will be decreaed if this relative decrease is greater than .eta_very_successful but smaller than .eta_too_successful

T eta_very_successful

see eta_successful

T eta_too_successful

see eta_successful

T weight_decrease_min

on very successful iterations, the regularization weight will be reduced by the factor .weight_decrease but no more than .weight_decrease_min while if the iteration is unsucceful, the weight will be increased by a factor .weight_increase but no more than .weight_increase_max (these are delta_1, delta_2, delta3 and delta_max in Gould, Porcelli and Toint, 2011)

T weight_decrease

see weight_decrease_min

T weight_increase

see weight_decrease_min

T weight_increase_max

see weight_decrease_min

T switch_to_newton

if the value of the two-norm of the projected gradient is less than .switch_to_newton, a switch is made from the Gauss-Newton model to the Newton one when .newton_acceleration is true

T cpu_time_limit

the maximum CPU time allowed (-ve means infinite)

T clock_time_limit

the maximum elapsed clock time allowed (-ve means infinite)

Bool newton_acceleration

if they are available, second derivatives should be used to accelerate the convergence of the algorithm

Bool magic_step

allow the user to perform a “magic” step to improve the objective

Bool print_obj

print values of the objective/gradient rather than $\|r\|$ and its gradient

Bool space_critical

if .space_critical true, every effort will be made to use as little space as possible. This may result in longer computation time

Bool deallocate_error_fatal

if .deallocate_error_fatal is true, any array/pointer deallocation error will terminate execution. Otherwise, computation will continue

NTuple{31,Cchar} prefix

all output lines will be prefixed by .prefix(2:LEN(TRIM(.prefix))-1) where .prefix contains the required string enclosed in quotes, e.g. “string” or ‘string’

struct slls_control_type slls_control

control parameters for SLLS

struct sllsb_control_type sllsb_control

control parameters for SLLSB