! File: GlobSol.CFG  Configuration parameters for the GlobSol package
!  When adding configuration variables, the "set configuration variables"
!  parts of both codlvars.f90 and gradvars.f90 need to be changed.
!
! =============================================================

! 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 = F
! 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: INTEGER; Typical: 3
ERROR_PRINTING_IN_INTLIB = 3
!  controls the level of error printed in INTLIB routines.  IPRCTL=0 prints
!        all levels, while IPRCTL=1 prints only errors of level 1 or
!        greater.  If IPRTCL=4, then no error information is printed.

!
! Type: LOGICAL; Typical: F
WANT_TABLE = T
! 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
PRINTING_IN_LP = 0
! Amount of printing in the linear program creation and solution
! process

! Type: INTEGER;  Range: [0, 7];  Typical: 0
PRINTING_IN_PROBE = 0
! Amount of printing in the validated probing process

! 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_RUN_APPROXIMATE_OPTIMIZER = 0
! Amount of printing in the approximate solver interface routine
! (possibly unused)

! 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, 16];  Typical: 3
PRINT_LENGTH = 3
! Specifies the number of digits in the output
! On platforms without C-interoperability and David Gay's
! gdtoa package, or if USE_INTRINSIC_PRINTING is "T":
! 1 --  4 digits, 2 -- 18 digits
! On Windows systems with g95 and gcc --
!  PRINT_LENGTH is the actual number of digits to be printed.

! Type: LOGICAL;  Range: T, F;     Typical: T
USE_INTRINSIC_PRINTING = T
! If set to "F", David Gay's gdtoa is used to print
! interval and double precision quantities.  Otherwise, 
! Fortran's print statements are used (and hence the lower
! and upper bounds of intervals are not correctly rounded,
! and limited numbers of digits printed can be selected).

! 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: [0, 1];  Typical: 0
PRINTING_IN_SPLIT = 0
! If set to "1", prints information about the point at which
! a box is split.

! Type: INTEGER; Range: [0, 6]; Typical: 0
PRINTING_IN_VALIDATE_FJ = 0
! Controls printing in the routine validate_FJ_in_subspace

! 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
SMALLEST_LIST_BOX_SIZE = 0
! This is the smallest size box that is stored on the list of boxes that
! possibly contain solutions.  If this is set smaller than
! SQRT(EPS_DOMAIN), then the smallest box that is stored on the list of
! boxes is SQRT(EPS_DOMAIN).  However, for problems with manifolds of
! singular solutions, this may need to be set larger; set
! SMALLEST_LIST_BOX_SIZE larger if GlobSol fails to complete, and
! increasing the maximum CPU time and MAXITR does not decrease the list
! of boxes yet to be considered.  However, if SMALLEST_LIST_BOX_SIZE is
! set too large, it may not be possible to obtain tight bounds on
! solutions. (Note that SMALLEST_LIST_BOX_SIZE represents a
! coordinatewise ABSOLUTE tolerance.  Thus, we assume the coordinates
! are pre-scaled if this is used.)

! Type: DOUBLE PRECISION; Range: [0, 1]; Typical: 2D-3
EPS_LP_FIT = 1d-2
! Amount by which a linear programming relaxation of a variable
! can deviate from an actual value, in absolute terms.

! 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 = 500000
! 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: INTEGER; Range:[1, .]; Typical: 20
MAX_SUBDIVISIONS = 20
! Maximum number of subintervals to be used for each variable in the
! set selected to be subdivided, when a non-adaptive algorithm
! (such as that in f90intbi/run_solution_by_discretization.f90) is
! used.  It is also used as the bound on the number of subdivisions
! of resettable constants in test_reset_constants.

! Type: REAL (double precision); Range: > 0; Typical: 3600
MAX_CPU_SECONDS = 7200
! 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.)

MAX_LP_PRE = 10000000
! This sets the maximum number of LP problems that are allowed
! to be solved to compute LP preconditioners.

! 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: T
ALLOW_EPSILON_APPROXIMATE = F
! If set to T, a point is accepted as feasible if the range 
! of the constraints (both equality and inequality) is within
! EPS_DOMAIN of feasible. In that case, the algorithm is guaranteed
! to print at least one box containing an epsilon-approximate solution,
! in the sense that it contains a point that is minimal among all points
! such that the constraints are satisfied to with EPSILON_DOMAIN.  However,
! some delta-approximate solutions, with delta < EPS_DOMAIN, may be
! discarded.
!
! If ALLOW_EPSILON_APPROXIMATE is set to F, no actual solutions may
! be discarded.  This may make the problem much harder, especially if
! there are many equality constraints. 

! Type: LOGICAL; Typical: F
USES_INTERMEDIATE_VARIABLES = F
! If set to T, lower and upper bounds on a set of intermediate variables
! is assumed.  In that case, a file <problem name>.intermediate_variables
! can be present, to be read in by some routines.  The lines of this file
! should contain the following:
!    N_INTERMEDIATE_BOUNDS
!    VARIABLE_INDEX_1
!    VARIABLE_INDEX_2
!     .
!     .
!     .
!    VARIABLE_INDEX_N_INTERMEDIATE_BOUNDS
!    LB_1  UB_1
!    LB_2  UB_2
!     .
!     .
!     .
!    LB_N_INTERMEDIATE_BOUNDS UB_N_INTERMEDIATE_BOUNDS

! 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 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: T
DO_SPLITS_IN_SUBSIT = F
! In find_global_min,
! T if split intervals arising from the constraint propagation are
!   to be separately considered.
! F is the interval hull of disjoint intervals arising from the
!   constraint propagation is to be used instead.

! Type: LOGICAL;  Typical: F
SUE_USE_INNER_FOR_FEASIBILITY = F
! It is correct to set SUE_USE_INNER_FOR_FEASIBILITY = T only when
! the equality constraints are Single Use Expressions (SUE's); otherwise,
! GlobSol could give incorrect answers.  If the equality constraints
! are SUE's, then setting SUE_USE_INNER_FOR_FEASIBILITY = T causes
! inner arithmetic to be used in GlobSol at points where feasibility is
! to be verified.  Feasibility is then verified if the inner bounds for
! the function value contains 0.  This process can be only expected to
! work if the constants in the equality constraints are non-zero width
! intervals, such as with equality constraints of the form \A x - \b = 0,
! \A an interval matrix and \b an interval vector.

! 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 = F
! 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, between 0 and 1
! (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 less often, while
! ALPHA = 0 causes feasible points to always be sought.
! For optimization, a non-zero
! alpha should generally be used if the number of equality
! constraints is large relative to the dimension.  When
! LP_FILTER is used, it may be best to set ALPHA to some number
! greater than 1.

! 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 = 2
! Type 1 is inverse midpoint, type 2 is C-LP,
! type 3 is C-M, type 4 is E-m.  (See Kearfott's book.)
! This does not affect the interval Newton method in
! the overall box loop, where the C-LP preconditioner
! is always used.

DO_INFEASIBILITY_CHECK = T
! When set to "T", a check for existence of a C_LP preconditioner
! is done in the reduced interval Newton method.  (The
! check is according to a theorem characterizing the existence
! of a width-optimal preconditioner in Chenyi Hu's dissertation.)
! Recommended value: "T".  The computation is the same computation
! that is done to prepare to apply pivoting preconditioners,
! if pivoting preconditioners are used.
! Default if not appearing in the configuration file: "F".

DO_PIVOTING = T
! When set to "T," pivoting preconditioners are tried,
! and LP preconditioners are tried for a coordinate only
! when a width-optimal preconditioner exists for that coordinate.
! and when other preconditioners fail.
! When set to "F","  no pivoting preconditioners are tried,
! and optimal preconditioners  and /or inverse midpoint
! preconditioners are attempted for each coordinate.

DO_INV_MID = T
! When set to "T," inverse midpoint preconditioners are tried,
! and LP preconditioners are tried for a coordinate only
! when a width-optimal preconditioner exists for that coordinate.
! and pivoting preconditioners have failed (if tried).
! When set to "F","  no inverse midpoint preconditioners are tried,

TRY_C_LP_HEURISTIC = 1D10
! TRY_C_LP_HEURISTIC is a parameter in a heuristic that
! determines when to try to compute a C_LP preconditioner.
! TRY_C_LP_HEURISTIC>= 0.  If TRY_C_LP_HEURISTIC =1, then
! no preconditioners for which the unintersected image would
! would be narrower than X(K) are ignored.
!(Values of TRY_C_LP_HEURISTIC larger
! than 1 may also be used if \|F(XP)\| is relatively large.)  If
! TRY_C_LP_HEURISTIC = 0, then all preconditioners are ignored.

C_LP_SOLVER = 4
! Type: INTEGER; default: 1
! = 1: Manual Novoa's simplex method is used to compute
!      C-LP preconditioners for the interval Newton method
! = 2: the SLATEC routine DSPLP (a sparse Simplex implementation)
!      is used for C-LP preconditioners for the interval
!      Newton method
! = 3: the routine QSOPT is used.
! = 4: the routine CLP is used.

REUSE_PRECONDITIONERS = T
! Type: Integer; default: T
! = T: If an LP preconditioner for a coordinate was
!      successfully computed in a previous sweep of the
!      current Gauss--Seidel iteration, then it is not
!      recomputed, even though the interval Jacobi matrix has
!      been recomputed.
! = F: LP preconditioners are always recomputed for each
!      sweep of Gauss--Seidel iteration on a particular box.

USE_INEQ_PERTURB_FOR_FEAS = F
! Type: Logical; default: T
!  This variable has an effect only if there are no active
!  bound constraints (as defined in the box data file) and
!  no equality constraints.  If set to "T", then approximate
!  optimizing points obtained from the approximate optimizer
!  are perturbed in such a way that the perturbed point is
!  likely to be certainly feasible.  This may lead to
!  a sharper upper bound on the global optimum earlier in
!  the branch and bound process, and may thus cause the
!  branch and bound process to successfully terminate earlier.

! 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

APPROX_OPTIMIZER_TYPE = 7
! 0 = No iteration is done in precond/findopt.f90 to locate an
!     approximate feasible point.  (It is assumed in this case that
!     the point passed in XP is already an approximate optimizer.)
! 1 = Generalized Newton to obtain a feasible point (default)
! 2 = IPOPT with Fritz--John only
! 3 = Use both of approximate solution to an LP relaxation and
!     generalized Newton.
! 4 = Use both approximate solution to an LP relaxation and
!     IPOPT with Fritz--John only.
! 5 = Use only the approximate solution to an LP relaxation.
! 6 = Use only IPOPT with Fritz--John and feasibility verification
!     if Fritz--John fails.
! 7 = Use IPOPT with Fritz--John and feasibility verification
!     if Fritz--John fails, and also use LP relaxation.
! 8 = Use LP only

USE_LP = T
!     F -- Do not use approximating LP's to find lower bounds
!          on the objective and lower and upper bounds on the
!          function. (Presently the default)
!     T -- Use approximating LP's.

DO_PROBE = F
!     T -- If DO_PROBE = F, do not do "probing" (default).
!     F -- If DO_PROBE = T, do  "probing".

DO_PROBE_TESTS_3_AND_4 = F
!     T -- If DO_PROBE = F, this has no effect (default).
!     F -- If DO_PROBE = T, and DO_PROBE_TESTS_3_AND_4 = t,
           to tests 3 and 4 of the Ryoo and Sahinidis paper
           (that is, probe lower and upper bounds)

ITERATE_LP = F
!     T -- Iterate the process of substitution-iteration,
!          LP-filtering, and interval Newton reduction if
!          the box is reduced in at least two of these
!          processes.
!     F -- Bisect the resulting box if substitution-iteration,
!          LP-filtering, and the interval Newton are done only
!          once (in that sequence), regardless of the progress
!          made in any of them.

USE_REDUCED_SPACE = F
!     T -- Use convex subspace techniques in analyzing the
!          existence and uniqueness of local optima
!     F -- Do not use such techniques (default)

USE_HEURISTICALLY_INFLATED_BOX = F
!     This only has an effect when USE_REDUCED_SPACE = T
!
!     T -- Store a heuristically inflated box about optima
!          interior to a particular sub-box that have been
!          validated with the reduced-space algorithm in
!          the list of small, non-validated boxes, and
!          replace the current box with its complement in the
!          with respect to the heuristically inflated box.
!     F -- Do not use heuristically inflated boxes.

REDUCED_IN_BISECTION = T
!     T -- Bisect only on variables for which bisection has been
!          shown to be necessary for good approximation by linear
!          relaxations (This only makes sense if USE_LP = T)
!     F -- Select from the entire space of independent variables
!          for bisection (default)

USE_EPPERLY_SPLIT = 0
!     0 -- Use the midpoint of the coordinate interval
!          to split the box (i.e. do bisection, default)
!     1 -- Use the scheme of Epperly et al (1997) to decide
!          where to split the interval

ORDERED_LIST_IN_COMPLEMENTATION = 1
!  This variable controls the way that the complement of
!  a box x within a box y is taken.  (See Algorithm 10,
!  page 155, "Rigorous Global Search: Continuous Problems,"
!  Kearfott, Kluwer, 1996)
!     0 -- complement with respect to y_1 first, then with
!          respect to y_2, etc.
!     1 -- complement with respect to the coordinate k
!          with largest scaled width wid(x(k)) / max(mag(x(k),1)
!          first, then with the coordinate of secont largest
!          such scaled width, etc.

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