! File: GlobSol.CFG  Configuration parameters for the GlobSol package
!
! =============================================================

! OVERLOAD.CFG -- Section to configure how the code list is
!                 created and used.

! This section defines default values for the code list(s) configuration
! You may edit the values to suit your application.  We suggest using
! values about 3-5 times larger than you might guess, but values
! GREATLY larger than necessary may exhaust available memory in the
! code list generation and differentiation process.
! If a particular variable is left out, then the configuration
! file reader will issue a warning message, but a default value
! will be used.

! Type: LOGICAL;  Typical: F
USE_STANDARD_CODELIST_NAME = F
! If it is "F", the user is prompted for a code list file name
! and for a box data file number.  If it is "T", the default
! code list file name of "CODELIST" (except in the program
! optimize_codelist) and the default box data file number of
! "1" are used.  If "T", the program optimize_codelist uses the
! file CODELISTG.CDL as input and writes to the program
! CODELISTG.CDL as output.

! Type: INTEGER;  Range: [1, .];  Typical: 10000 (determined by model)
NEQMAX = 10000
! Maximum number of equality constraints

! Type: INTEGER;  Range: [1, .];  Typical: 100000 (determined by
! model)
NROWMAX = 1000000
! Maximum number of entries in the original OR gradient code list

! Type: INTEGER;  Range: [1, .];  Typical: 20000 (determined by model)
NCONSTMX = 20000
! Maximum number of literal constants stored in the code list

! Type: INTEGER;  Range: [1, .];  Typical: 100 (determined by model)
BRANCHMX = 100
! Maximum number of conditional branches (CHI) in the code list

! Type: INTEGER;  Range: [1, .];  Typical: 100 (calls of CDL_WRITE)
NSTRINGMX = 100
! The maximum number of strings to be stored in CDL_WRITE statements.

! Type: LOGICAL;  Typical: T (unless very small problem)
BINARY_CODELIST = T
! Format of the code list is either binary (T), or ASCII (F)

! =============================================================


! OPTTBND.CFG -- Section to configure tolerances and to control
!                printing.

!   This section  contains variables that determine how much
!   printing is done and which algorithms are used by the
!   optimizer. If a particular variable is left out, then the
!   configuration file reader will issue a warning message, but
!   a default value will be used.

!--------------------------------------------------------------
! SUBSECTION TO CONTROL PRINTING:
!--------------------------------------------------------------

!
! Type: LOGICAL; Typical: F
WANT_TABLE = F
! Controls whether a line of statistics is added to a file
! OPTTBND.TBL or ROOTSTAT.TBL
! Type: INTEGER;  Range: [0, 7];  Typical: 0
PRINTING_IN_OVERALL_ALGORITHM = 0
! Amount of printing in find_roots or find_global_min

! Type: INTEGER;  Range: [0, 7];  Typical: 0
PRINT_REDUCED_INTERVAL_NEWTON = 0
! Amount of printing in the interval Newton routines.

! Type: INTEGER;  Range: [0, 7];  Typical: 0
PRINT_REDUCED_GS = 0
! Amount of printing in the interval Gauss-Seidel method

! Type: INTEGER;  Range: [0, 5];  Typical: 0
PRINT_LANCELOT_OPT = 0
! Amount of printing in the approximate solver interface routine
! (unused with the present default approximate solver)

! Type: INTEGER;  Range: [0, 5];  Typical: 0
PRINT_FIND_APPROX_OPT = 0
! Amount of printing in FIND_APPROX_OPT that finds an approximate
! optimum and proves that a feasible point exists near it
! Special feature: PRINT_FIND_APPROX_OPT = -1 prints successfully
! found approximate feasible points  are also printed to unit
! 25.

! Type: INTEGER;  Range: [0, 3];  Typical: 0
PRINT_CERTAINLY_FEASIBLE = 0
! Amount of printing in the routine that verifies if a feasible point
! exists in a certain box

! Type: INTEGER;  Range: [0, 2];  Typical: 0
PRINT_CONSTRUCT_FEASIBLE = 0
! Amount of printing in CONSTRUCT_FEASIBLE_REGION that constructs a
! box about an approximate feasible point within which a feasible
! point is verified to exist.

! Type: INTEGER;  Range: [0, 7];  Typical: 0
PRINTBDY = 0
! Amount of printing in the routine PEEL_BOUNDARY_DENSE

! Type: INTEGER;  Range: [0, 5];  Typical: 0
PRINT_COMPLEMENT_LIST = 0
! Amount of printing in the routine COMPLEMENT_DENSE_OPT that takes
! the set complement of a box in a list of boxes

! Type: INTEGER;  Range: [0, 5];  Typical: 0
PRINT_INFLATE = 0
! Amount of printing in the routine that constructs a box about
! an approximate optimum (or solution) in which a unique
! critical point of the Fritz John equations (or solution to
! the nonlinear system) can be proven to lie

! Type: INTEGER;  Range: [1, 2];  Typical: 1
PRINT_LENGTH = 1
! Specifies the number of digits in the output:
! 1 --  4 digits, 2 -- 18 digits

! Type: INTEGER;  Range: [0, 5];  Typical: 0
PRINT_SUBSIT = 0
! If running find_global_min,
! amount of printing in the routine SUBSIT_DENSE_OPT that performs
! constraint propagation techniques ("substitution-iteration") on
! the intermediate quantities computed in evaluation of the code list,
! given a new upper bound for the global minimizer.
! If running find_roots,
! amount of printing in the routine USER_SUBSIT, if USER_SUBSIT is
! used.  (General substitution-iteration is not used in root-finding,
! only in the optimization package.)

! Type: INTEGER;  Range: [0, 5];  Typical: 0
PRINTING_IN_FUNCTIONS = 0
! Amount of printing in the code list function routines

! Type: INTEGER;  Range: [1, 99];  Typical: 6 or 7
GOU = 7
! Fortran logical unit number for the output from find_global_min
! or find_roots.
! 6 -- send output to the screen (may be re-directed);
! 7 -- file <name>.OT# for find_global_min and file <name>.RO#
!      for find_roots, where <name> matches the name of the
!      program, and # matches the number of the box definition
!      file <name>.DT#
! Normally, the authors use GOU = 7, and write the results to a file.
! However, if things are not going well, and the program crashes,
! the output file often looses information that HAD been reported,
! especially if we use various print flags to report information for
! diagnosis.  In this situation, GOU = 6, with screen output captured
! in a script file captures everything that is reported.

!--------------------------------------------------------------
! SUBSECTION TO SET TOLERANCES:
!--------------------------------------------------------------

! Type: DOUBLE PRECISION;  Range: [0, 1];  Typical: 1.0D-7
EPS_DOMAIN = 1.0D-7
! Domain tolerance used to determine minimum box sizes in the
! tessellation and inflation. If output is not satisfactory,
! experiment with EPS_DOMAIN. Smaller values sometimes lead to
! performance improvements. Larger values may be necessary when
! manifolds of singular solutions exist.
! If a box data file <filename>.DT? is read in, the value at the
! top of that file takes precedence over this value.
! This value should not be too small or two large. Unverified
! small boxes are expanded to scaled widths proportional to
! SQRT(EPS_DOMAIN). The stopping tolerance for the approximate
! feasible point finder is proportional to EPS_DOMAIN**1.5.

! Type: DOUBLE PRECISION;  Range: [0, 1];  Typical: 0.05
      EPS_CHECK = .05D0
! EPS_CHECK is used in two places: (i) to determine when two
! intervals are approximately the same, for deciding when to
! stop iteration processes that narrow intervals, and (ii) in the
! substitution-iteration (constrant propagation) process for a
! similar reason.  If EPS_CHECK is too large, then the
! acceleration from iteration processes is lost.  If EPS_CHECK is
! too small, the algorithm becomes inefficient because there are
! many iterations with little progress.  In the iteration
! processes, EPS_CHECK is used as follows:
!      DIAM_DIFF = ABS (NEW_RESULT%LOWER - XL%LOWER) + &
!                  ABS (NEW_RESULT%UPPER - XL%UPPER)
!      IF( DIAM_DIFF  .LE. EPS_CHECK * NEW_DIAM) THEN
!         <xl and new_result are considered equal>
! In substitution-iteration, EPS_CHECK is used as an absolute
! tolerance to determine when an equality constraint value
! contains non-zero values, when an inequality constraint value
! contains positive values, and when a gradient component value
! contains non-zero values,

! Type: DOUBLE PRECISION; Range: [0,1]; Typical: 0.5
PHI_THICKNESS_FACTOR = 0.5
! In find_global_min,
! used as part of determination of whether to continue bisection
! of a box. The box is possibly bisected further if the ratio of
! point function width to interval function width is smaller
! than PHI_THICKNESS_FACTOR.  Set it to 0 to turn the test off
! when PHI_MUST_ CONVERGE is set to "false", and set it to 1
! to turn the test off when PHI_MUST_ CONVERGE is set to
! "true".

! Type: DOUBLE PRECISION; Range: [0,1]; Typical: 0.5
EQ_CNS_THICKNESS_FACTOR = 0.5
! In find_global_min,
! used as part of determination of whether to continue
! bisection of a box. The box is possibly bisected further if
! the ratio of each point equality constraint residual width to
! interval equality constraint residual width is smaller than
! EQ_CNS_THICKNESS_FACTOR.  Set it to 0 to turn the test off
! when C_MUST_ CONVERGE is set to "false", and set it to 1
! to turn the test off when C_MUST_ CONVERGE is set to
! "true".

! Type: DOUBLE PRECISION; Range: [0,1]; Typical: 0.5
INEQ_CNS_THICKNESS_FACTOR = 0.5
! In find_global_min,
! used as part of determination of whether to continue
! bisection of a box. The box is possibly bisected further if
! the ratio of each point inequality constraint residual width
! to interval inequality constraint residual width is smaller
! than INEQ_CNS_THICKNESS_FACTOR.  Set it to 0 to turn the test
! off when IC_MUST_ CONVERGE is set to "false", and set it
! to 1 to turn the test off when IC_MUST_ CONVERGE is set to
! "true".

! Type: LOGICAL; Typical: T
PHI_MUST_CONVERGE = T
! In find_global_min,
! used as part of determination of whether to continue bisection
! of a box. If set to "T", then either the width of the interval
! objective function must be small, as defined by parameter
! PHI_CONVERGENCE_FACTOR, or else the objective function value
! must be thick, as defined by PHI_THICKNESS_FACTOR, for
! bisection to stop. If set to "F", bisection may cease due to
! some other range convergence criterion, even if the objective
! function range is not small.

! Type: LOGICAL; Typical: T
EQ_CNS_MUST_CONVERGE = T
! In find_global_min,
! used as part of determination of whether to continue bisection
! of a box. If set to "T", then either the width of each
! interval equality constraint must be small, as defined by
! parameter EQ_CNS_CONVERGENCE_FACTOR, or else each interval
! equality constraint must be thick, as defined by
! EQ_CNS_THICKNESS_FACTOR, for bisection to stop. If set to "F",
! bisection may cease due to some other range convergence
! criterion, even if the equality constraint ranges are not
! small.

! Type: LOGICAL; Typical: T
INEQ_CNS_MUST_CONVERGE = T
! In find_global_min,
! used as part of determination of whether to continue bisection
! of a box. If set to "T", then either the width of each
! interval inequality constraint must be small, as defined by
! parameter INEQ_CNS_CONVERGENCE_FACTOR, or else each interval
! inequality constraint must be thick, as defined by
! INEQ_CNS_THICKNESS_FACTOR, for bisection to stop. If set to
! "F", bisection may cease due to some other range convergence
! criterion, even if the inequality constraint ranges are not
! small.

! Type: DOUBLE PRECISION; Range: [0,2+]; Typical: 1D-14
PHI_CONVERGENCE_FACTOR = 1D-14
! In find_global_min,
! used as part of determination of whether to continue bisection
! of a box. The box is possibly bisected further if the ratio of
! the width of the interval objective function to the magniude
! of the interval objective function is greater than
! PHI_CONVERGENCE_FACTOR. Set it to 0 to turn the test off when
! PHI_MUST_CONVERGE is set to "false", and set it to some number
! greater than 2 to turn the test off when PHI_MUST_CONVERGE is
! set to "true".

! Type: DOUBLE PRECISION; Range: [0,2+]; Typical: 1D-14
EQ_CNS_CONVERGENCE_FACTOR = 1D-14
! In find_global_min,
! used as part of determination of whether to continue bisection
! of a box. The box is possibly bisected further if the width of
! an interval equality constraint is greater than
! EQ_CNS_CONVERGENCE_FACTOR. Set it to 0 to turn the test off
! when EQ_CNS_MUST_CONVERGE is set to "false", and set it to
! some number greater than the maximum equality constraint width to
! turn the test off when EQ_CNS_MUST_CONVERGE is set to "true".

! Type: DOUBLE PRECISION; Range: [0,2+]; Typical: 1D-14
INEQ_CNS_CONVERGENCE_FACTOR = 1D-14
! In find_global_min,
! used as part of determination of whether to continue bisection
! of a box. The box is possibly bisected further if an
! inequality constraint is not certainly feasible and if the
! width of that interval equality constraint is greater than
! INEQ_CNS_CONVERGENCE_FACTOR. Set it to 0 to turn the test off
! when INEQ_CNS_MUST_CONVERGE is set to "false", and set it to
! some number greater than the maximum width of the inequality
! constraintsto turn the test off when INEQ_CNS_MUST_CONVERGE  is
! set to "true".

!--------------------------------------------------------------
! SUBSECTION TO CONTROL THE ALGORITHMS:
!--------------------------------------------------------------

!  Subsubsection with limits on iterations --
!  ---------------------------------------

! Type: INTEGER;  Range: [1, .];  Typical: 20000
MAXITR = 20000
! Maximum number of boxes allowed to be processed in the overall
! algorithm.  This number can be adjusted to make find_global_min terminate
! prematurely if you suspect the problem has a manifold of solutions.
! Note: This number represents the maximum number of boxes
! allowed in a single call to RIGOROUS_GLOBAL_SEARCH.  (The
! total number of boxes in a run may be larger if the algorithm
! is restarted.)

! Type: REAL (double precision); Range: > 0; Typical: 3600
MAX_CPU_SECONDS = 3600
! Maximum number of CPU seconds in a single call to
! RIGOROUS_GLOBAL_SEARCH.  (The total number of CPU seconds in
! a run may be larger if the algorithm is restarted.)

! Type: INTEGER;  Range: [1, .];  Typical: 100
MAX_NEWT_ITER  = 100
! Maximum number of interval Newton iterations for
! GENERAL_INTERVAL_NEWTON_METHOD, LS_INTERVAL_NEWTON_METHOD, and
! OPT_INTERVAL_NEWTON_METHOD.  This parameter only affects execution
! in the stand-alone program run_inwt and in find_global_min only
! when either least-squares mode or full-space mode is used.

! Type: INTEGER;  Range: [1, .];  Typical: 50
MAXIT_POINT_NEWTON = 50
! Maximum number of point Newton iterations

! Type: INTEGER;  Range: [1, .]; Typical: 100
MAX_POINT_SOLVER_TRIES = 100
! The maximum number of random starts of the point solver in trying
! to obtain a feasible point.

!  Subsubsection with other algorithm controls --
!  -------------------------------------------
!
! Type: LOGICAL; Typical: F
PROMPTING = F
! Controls whether prompts such as
!     "Input the code list file name"
! are printed to the terminal.  PROMPTING = F indicates that
! such messages are not printed.

! Type: LOGICAL; Typical: F
CONTINUITY_ACROSS_BRANCHES = F
! Controls how differentiation is done with respect to the CHI
! function. This variable should be set depending on whether the
! left branch and right branch of the CHI function match at the
! branch point.  For example, if the function CHI(X,-1,1) is
! used, then CONTINUITY_ACROSS_BRANCHES should be set to "F",
! whereas, if CHI(X,-X,X) is used, then
! CONTINUITY_ACROSS_BRANCHES may be set to "T".  It is always
! safe, but may not be efficient, to set it to "F".  It should
! ALWAYS be set to "F" for optimization.

! Type: LOGICAL;  Typical: T
DO_INTERVAL_NEWTON = T
! T if interval Newton steps are to be used to reduce the size of the
! boxes and F otherwise

! Type: LOGICAL;  Typical: T
DO_MIDPOINT_TEST = T
! In find_global_min,
! T if the midpoint test is to be done, and F otherwise.
!   "T" is highly recommended; "F" is mainly for algorithmic research

! Type: LOGICAL;  Typical: T
QUADRATIC = T
! In find_global_min,
! T if the quadratic normalization conditions for the Fritz John
! equations is to be used, and F if the linear, interval normalization
! is to be used. Experiments have shown that "T" is usually better

! Type: LOGICAL;  Typical: F
FULL_SPACE = F
! In find_global_min,
! T if the bound constraints are to be included in the Fritz John
! equations, and F otherwise.
! Experiments have shown that "F" is usually better.

! Type: LOGICAL;  Typical: T
USE_GRADIENT_TEST = T
! In find_global_min,
! T if the monotonicity test is to be used, and F otherwise
!   "T" is highly recommended; "F" is mainly for algorithmic research.

! Type: LOGICAL;  Typical: T
USE_SUBSIT = T
! In find_global_min,
! T if the user-defined version of the substitution iteration
! process is to be used, and F otherwise.  The global algorithm
! is usually, but not always, more efficient with "T".

! Type: LOGICAL;  Typical: F
USE_USER_SUBSIT = F
! In find_roots,
! T if the user-defined version of the substitution iteration
! process is to be used, and F otherwise.  The normal setting
! is F in this case.

! Type: LOGICAL;  Typical: F
LEAST_SQUARES_FUNCTIONS = F
! In find_global_min
! F if objective is not a sum of squares.  For least squares problems, the
! objective is often ill-conditioned.  If LEAST_SQUARES_FUNCTIONS is T,
! we code the TERMS of the objective, not the sum of squares, and
! find_global_min uses special techniques.

! Type: LOGICAL: Typical: F
NONLINEAR_SYSTEM = T
! Set this variable to "True" if find_global_min is to be used
! to find the solution set to a nonlinear system of equations,
! instead of constrained optimization. If NONLINEAR_SYSTEM=T,
! the system of equations is defined as the equality
! constraints. The user's objective function should either be
! constaint or have identical minima at the solutions to the
! nonlinear system. The objective and inequality constraints (if
! any) are not used in the verification process (as with
! constrained optimization), but are used only as "helpers" to
! help eliminate regions in which the objective is high or the
! inequality constraints are violated.

! Type: LOGICAL;  Typical: T
USE_SECOND_ORDER = T
! In find_roots,
! T if second order (mean-value) extensions of the residuals
! are to be used on every box (to attempt to eliminate from
! consideration) and F otherwise.  (Second order extensions are
! always used on small boxes that have not yet been verified.)

! Type: LOGICAL;  Typical: T
REFINEMENT_IN_VERIFICATION = T
! In find_roots,
! T if, once a small box has been verified to contain at least one
!    root (using slopes), the interval Newton method is to continue
!    to make that box smaller. (A large box in which uniqueness is
!    proven is subsequently constructed about this small box.)
! F if no such refinement is to occur.

! Type: DOUBLE PRECISION; Typical: 0.5D0
ALPHA = 0.5D0
! In find_roots and find_global_min,
! a heuristic parameter for determining when to try to
! find an approximate root in a box, based on interval function
! values.  (See "Empirical Evaluation of Innovations in Interval
! Branch and Bound Algorithms for Nonlinear Systems," R. B. Kearfott,
! SIAM J. Sci. Comput 18 (2), pp. 574--594, March, 1997.)  It has
! been determined that, for many problems, ALPHA = 0.5 is good
! for nonlinear equations..
! For nonlinear equations, it applies to the equations. Larger
! ALPHA causes feasible points to be sought more often, while
! ALPHA = 0 turns the test off. For optimization, a non-zero
! alpha should generally be used if the number of equality
! constraints is large relative to the dimension.

! Type: LOGICAL; Typical: F
APPROX_OPT_BEFORE_BISECTION = F
! If set to "True", the approximate optimizer is tried before
! each bisection; if set to "false", the approximate optimizer is
! not tried. On some problems, this leads to excessive
! computation, while, on others, it is necessary to get a verified
! feasible point with a low objective value.  Set it to "F" if
! there are few constraints, and try setting it to "T" if the
! problem is a nonlinear system solved as an optimization
! problem, especially if non-isolated solutions are suspected.

! Type: DOUBLE PRECISION: Typical: 10
SINGULAR_EXPANSION_FACTOR = 10
! In find_global_min, a parameter that determines by how much a
! small box is expanded before trying to prove existence and
! uniqueness.  Larger values lead to larger boxes, and may help
! avoid clustering of many small boxes around a solution when
! the optimizer corresponds to an ill-conditioned Hessian .
! However, larger values may also lead to less accurate
! enclosures, unless the value is too large.  The parameter is
! used in rigorous_global_search.f90 and in findopt.f90 as
! follows:
!             SMEAR = SINGULAR_EXPANSION_FACTOR  * &
!                      MAX(ABS(XTP),1D0) * SQRT(EPS_DOMAIN)
!             APPROX_OPT_BOX%X(I)%LOWER = (XTP - SMEAR)
!             APPROX_OPT_BOX%X(I)%UPPER = (XTP + SMEAR)
!             APPROX_OPT_BOX%SIDE(I) = .FALSE.

! Type: INTEGER;  Range: [1, 4];  Typical: 1
PRECONDITIONER_TYPE = 1
! Type 1 is inverse midpoint, type 2 is C-LP,
! type 3 is C-M, type 4 is E-m.  (See Kearfott's book.)

! Type: INTEGER;  Range: [1, 2];  Typical: 2
SOLVER_TYPE = 2
! Type 1 is Gaussian elimination, type 2 is Gauss--Seidel

! Type: INTEGER;  Range: [1, 2];  Typical: 1
MATRIX_TYPE = 1
! Type 1 is interval Jacobi, type 2 is slope

!--------------------------------------------------------------
! SUBSECTION TO TURN ON AND OFF USE OF TAYLOR MODELS:
!--------------------------------------------------------------

! Type: LOGICAL; Typical: F
USE_TAYLOR_EQUALITY_CONSTRAINTS = F

! Type: LOGICAL; Typical: F
USE_TAYLOR_INEQ_CONSTRAINTS = F

! Type: LOGICAL; Typical: F
USE_TAYLOR_OBJECTIVE = F

! Type: LOGICAL; Typical: F
USE_TAYLOR_EQ_CNS_GRD = F

! Type: LOGICAL; Typical: F
USE_TAYLOR_GRAD = F

! Type: LOGICAL; Typical: F
USE_TAYLOR_INEQ_CNS_GRD = F

! Type: LOGICAL; Typical: F
USE_TAYLOR_REDUCED_INEWTON = F

! Type: INTEGER: Typical: 5
COSY_POLYNOMIAL_ORDER = 5