dgo_control_type structure#

#include <galahad_dgo.h>

struct dgo_control_type {
    // components

    bool f_indexing;
    ipc_ error;
    ipc_ out;
    ipc_ print_level;
    ipc_ start_print;
    ipc_ stop_print;
    ipc_ print_gap;
    ipc_ maxit;
    ipc_ max_evals;
    ipc_ dictionary_size;
    ipc_ alive_unit;
    char alive_file[31];
    rpc_ infinity;
    rpc_ lipschitz_lower_bound;
    rpc_ lipschitz_reliability;
    rpc_ lipschitz_control;
    rpc_ stop_length;
    rpc_ stop_f;
    rpc_ obj_unbounded;
    rpc_ cpu_time_limit;
    rpc_ clock_time_limit;
    bool hessian_available;
    bool prune;
    bool perform_local_optimization;
    bool space_critical;
    bool deallocate_error_fatal;
    char prefix[31];
    struct hash_control_type hash_control;
    struct ugo_control_type ugo_control;
    struct trb_control_type trb_control;
};

detailed documentation#

control derived type as a C struct

components#

bool f_indexing

use C or Fortran sparse matrix indexing

ipc_ error

error and warning diagnostics occur on stream error

ipc_ out

general output occurs on stream out

ipc_ print_level

the level of output required. Possible values are:

  • \(\leq\) 0 no output,

  • 1 a one-line summary for every improvement

  • 2 a summary of each iteration

  • \(\geq\) 3 increasingly verbose (debugging) output

ipc_ start_print

any printing will start on this iteration

ipc_ stop_print

any printing will stop on this iteration

ipc_ print_gap

the number of iterations between printing

ipc_ maxit

the maximum number of iterations performed

ipc_ max_evals

the maximum number of function evaluations made

ipc_ dictionary_size

the size of the initial hash dictionary

ipc_ alive_unit

removal of the file alive_file from unit alive_unit terminates execution

char alive_file[31]

see alive_unit

rpc_ infinity

any bound larger than infinity in modulus will be regarded as infinite

rpc_ lipschitz_lower_bound

a small positive constant (<= 1e-6) that ensure that the estimted gradient Lipschitz constant is not too small

rpc_ lipschitz_reliability

the Lipschitz reliability parameter, the Lipschiz constant used will be a factor lipschitz_reliability times the largest value observed

rpc_ lipschitz_control

the reliablity control parameter, the actual reliability parameter used will be .lipschitz_reliability

  • MAX( 1, n - 1 ) * .lipschitz_control / iteration

rpc_ stop_length

the iteration will stop if the length, delta, of the diagonal in the box with the smallest-found objective function is smaller than .stop_length times that of the original bound box, delta_0

rpc_ stop_f

the iteration will stop if the gap between the best objective value found and the smallest lower bound is smaller than .stop_f

rpc_ obj_unbounded

the smallest value the objective function may take before the problem is marked as unbounded

rpc_ cpu_time_limit

the maximum CPU time allowed (-ve means infinite)

rpc_ clock_time_limit

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

bool hessian_available

is the Hessian matrix of second derivatives available or is access only via matrix-vector products?

bool prune

should boxes that cannot contain the global minimizer be pruned (i.e., removed from further consideration)?

bool perform_local_optimization

should approximate minimizers be impoved by judicious local minimization?

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

char prefix[31]

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 hash_control_type hash_control

control parameters for HASH

struct ugo_control_type ugo_control

control parameters for UGO

struct trb_control_type trb_control

control parameters for TRB