GitHub

Types

EAGO.AbstractCache — Type
abstract type AbstractCache

Abstract supertype used for information storage object the directed acyclic graph.

source
EAGO.AffineFunctionEq — Type
mutable struct AffineFunctionEq <: EAGO.AbstractEAGOConstraint

Representation of an affine equality. Currently only used for bound tightening.

  • terms::Vector{Tuple{Float64, Int64}}

  • constant::Float64

  • len::Int64

source
EAGO.AffineFunctionIneq — Type
mutable struct AffineFunctionIneq <: EAGO.AbstractEAGOConstraint

Representation of an affine inequality. Currently only used for bound tightening.

  • terms::Vector{Tuple{Float64, Int64}}

  • constant::Float64

  • len::Int64

source
EAGO.BufferedNonlinearFunction — Type
mutable struct BufferedNonlinearFunction{V, N, T<:RelaxTag} <: EAGO.AbstractEAGOConstraint

Stores a general nonlinear function with a buffer represented by the sum of a tape and a scalar affine function.

source
EAGO.BufferedQuadraticEq — Type
mutable struct BufferedQuadraticEq <: EAGO.AbstractEAGOConstraint

Representation of a general quadratic equality constraint with a buffer.

  • func::MathOptInterface.ScalarQuadraticFunction{Float64}

  • minus_func::MathOptInterface.ScalarQuadraticFunction{Float64}

  • buffer::Dict{Int64, Float64}

  • saf::MathOptInterface.ScalarAffineFunction{Float64}

  • len::Int64

source
EAGO.BufferedQuadraticIneq — Type
mutable struct BufferedQuadraticIneq <: EAGO.AbstractEAGOConstraint

Representation of a general quadratic inequality constraint with a buffer.

  • func::MathOptInterface.ScalarQuadraticFunction{Float64}

  • buffer::Dict{Int64, Float64}

  • saf::MathOptInterface.ScalarAffineFunction{Float64}

  • len::Int64

source
EAGO.BufferedSOC — Type
mutable struct BufferedSOC <: EAGO.AbstractEAGOConstraint

Representation of a second-order cone with a buffer.

source
EAGO.EAGOParameters — Type
mutable struct EAGOParameters

Storage for parameters that do not change during a global solve.

  • presolve_scrubber_flag::Bool: Should EAGO attempt to remove type-assert issues for user-defined functions (default = false)

  • presolve_to_JuMP_flag::Bool: Create and use DAG representations of user-defined functions (default = false)

  • presolve_flatten_flag::Bool: Rerrange the DAG using registered transformations (default = false)

  • conic_convert_quadratic::Bool: Attempt to bridge convex constraint to second-order cone (default = false)

  • log_on::Bool: Turn logging on; record global bounds, node count, and run time. Additional options are available for recording information specific to subproblems (default = false)

  • log_subproblem_info::Bool: Turn on logging of times and feasibility of subproblems (default = false)

  • log_interval::Int64: Log data every log_interval iterations (default = 1)

  • verbosity::Int64: The amount of information that should be printed to console while solving. Values range from 0 - 4: 0 is silent, 1 shows iteration summary statistics only, 2-4 show varying degrees of detail about calculations within each iteration (default = 1)

  • output_iterations::Int64: Display summary of iteration to console every output_iterations (default = 1000)

  • header_iterations::Int64: Display header for summary to console every output_iterations (default = 100000)

  • branch_cvx_factor::Float64: Convex coefficient used to select branch point. Branch point is given by branch_cvx_factor*xmid + (1-branch_cvx_factor)*xsol (default = 0.25)

  • branch_offset::Float64: Minimum distance from bound to have branch point, normalized by width of dimension to branch on (default = 0.15)

  • branch_pseudocost_on::Bool: Indicate that pseudocost branching should be used (default = false)

  • branch_variable::Vector{Bool}: Variables to branch on (default is all nonlinear)

  • branch_max_repetitions::Int64: [FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED] Number of times to repeat node processing prior to branching (default = 4)

  • branch_repetition_tol::Float64: [FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED] Volume ratio tolerance required to repeat processing the current node (default = 0.9)

  • node_limit::Int64: Maximum number of nodes (default = 1E7)

  • time_limit::Float64: Maximum CPU time in seconds (default = 3600)

  • iteration_limit::Int64: Maximum number of iterations (default 1E9)

  • absolute_tolerance::Float64: Absolute tolerance for termination (default = 1E-3)

  • relative_tolerance::Float64: Relative tolerance for termination (default = 1E-3)

  • absolute_constraint_feas_tolerance::Float64: Absolute constraint feasibility tolerance (default = 1E-8)

  • cp_depth::Int64: Depth in B&B tree above which constraint propagation should be disabled (default = 0)

  • cp_repetitions::Int64: Number of times to repeat forward-reverse pass routine (default = 0)

  • cp_tolerance::Float64: Disable constraint propagation if the ratio of new node volume to beginning node volume exceeds this number (default = 0.99)

  • cp_interval_only::Bool: Use only valid interval bounds during constraint propagation (default = false)

  • obbt_depth::Int64: Depth in B&B tree above which OBBT should be disabled (default = 6)

  • obbt_repetitions::Int64: Number of repetitions of OBBT to perform in preprocessing (default = 3)

  • obbt_aggressive_on::Bool: Turn on aggresive OBBT (default = true)

  • obbt_aggressive_max_iteration::Int64: Maximum iteration to perform aggresive OBBT (default = 2)

  • obbt_aggressive_min_dimension::Int64: Minimum dimension to perform aggresive OBBT (default = 2)

  • obbt_tolerance::Float64: Tolerance to consider bounds equal (default = 1E-10)

  • fbbt_lp_depth::Int64: Depth in B&B tree above which linear FBBT should be disabled (default = 1000)

  • fbbt_lp_repetitions::Int64: Number of repetitions of linear FBBT to perform in preprocessing (default = 3)

  • dbbt_depth::Int64: Depth in B&B tree above which duality-based bound tightening should be disabled (default = 1E10)

  • dbbt_tolerance::Float64: New bound is considered equal to the prior bound if within dbbt_tolerance (default = 1E-8)

  • relax_tag::RelaxTag: RelaxTag used to specify type of McCormick operator (default = NS())

  • subgrad_tighten::Bool: Perform tightening of interval bounds using subgradients at each factor in each nonlinear tape during a forward pass (default = true)

  • reverse_subgrad_tighten::Bool: Perform tightening of interval bounds using subgradients at each factor in each nonlinear tape during a reverse pass (default = false)

  • subgrad_tol::Float64: Outer-round computed subgradient bounds by this amount (default = 1E-10)

  • mul_relax_style::Int64: Select the type of relaxation to use for the bilinear term (multiplication): 0 corresponds to a standard McCormick arithmetic approach. Settings 1-3 augment the standard McCormick relaxation with implied apriori relaxations: (1) corresponds to a subgradient-based apriori relaxation approach; (2) corresponds to an affine arithmetic-based apriori approach; and (3) corresponds to a enumerative apriori relaxation-based approach (default = 0)

  • cut_min_iterations::Int64: Minimum number of cuts at each node to attempt (unsafe cuts not necessarily added) (default = 2)

  • cut_max_iterations::Int64: Maximum number of cuts at each node to attempt (default = 8)

  • cut_tolerance_abs::Float64: Absolute tolerance checked for continuing cut (default = 1E-6)

  • cut_tolerance_rel::Float64: Relative tolerance checked for continuing cut (default = 1E-3)

  • cut_safe_on::Bool: Use tolerances to determine safe cuts in a Khajavirad 2018 manner (default = true)

  • cut_safe_l::Float64: Lower tolerance for safe-lp cut, Khajavirad 2018 (default = 1E-7)

  • cut_safe_u::Float64: Upper tolerance for safe-lp cut, Khajavirad 2018 (default = 1E7)

  • cut_safe_b::Float64: Constant tolerance for safe-lp cut, Khajavirad 2018 (default = 1E9)

  • upper_bounding_depth::Int64: Solve upper problem for every node with depth less than upper_bounding_depth, and otherwise solve upper problems with a probability of (1/2)^(depth-upper_bounding_depth) (default = 8)

  • domain_violation_guard_on::Bool: (Unused) Protect against domain violation (default = false)

  • domain_violation_ϵ::Float64: (Unused) Amount about a domain violation to ignore when propagating bounds (default = 1E-9)

  • user_solver_config::Bool: If true, EAGO forgoes its default configuration process for subsolvers (default = false)

  • integer_abs_tol::Float64: Absolute tolerance used to check for integrality of decision variables (default = 1E-9)

  • integer_rel_tol::Float64: Relative tolerance used to check for integrality of decision variables (default = 1E-9)

  • force_global_solve::Bool: Ignore EAGO's ability to parse problem types and force it to run global optimization (default = false)

  • unbounded_check::Bool: Check that all branching variables have finite bounds and set them to +/- 1E10 if not (default = true)

source
EAGO.Evaluator — Type
Evaluator

MOI.AbstractNLPEvaluator for calculating relaxations of nonlinear terms.

Checks that the resulting value should be a number.

  • user_operators::EAGO.OperatorRegistry

  • has_user_mv_operator::Bool

  • num_mv_buffer::Vector{Float64}

  • parameter_values::Vector{Float64}

  • node::NodeBB

  • variable_values::EAGO.VariableValues{Float64}

  • subgrad_tighten::Bool

  • reverse_subgrad_tighten::Bool

  • subexpressions::Vector{EAGO.NonlinearExpression}

  • subexpressions_eval::Vector{Bool}

  • is_post::Bool

  • is_intersect::Bool

  • is_first_eval::Bool

  • interval_intersect::Bool

  • subgrad_tol::Float64

  • relax_type::EAGO.RelaxType

  • pass_number::Int64

source
EAGO.ExtensionType — Type
abstract type ExtensionType

An abstract type the subtypes of which are associated with functions method overloaded for new extensions. An instance of this is the DefaultExt <: ExtensionType structure in the ext_type field of the Optimizer.

source
EAGO.GlobalEndState — Type
primitive type GlobalEndState <: Enum{Int32} 32

An Enum of possible values for EAGO's termination status. This attribute is used by EAGO to explain why the optimizer stopped executing in the most recent call to optimize!. See also MathOptInterface.TerminationStatusCode.

If no call has been made to optimize!, the GlobalEndState value is:

  • GS_UNSET: The optimization algorithm has not stated.

OK

  • GS_OPTIMAL: A globally optimal solution was found.
  • GS_INFEASIBLE: The algorithm concluded that no feasible solution exists.

Limits reached

  • GS_NODE_LIMIT: The branch-and-bound algorithm stopped because it reached the user-set maximum number of nodes in the branch-and-bound tree.
  • GS_ITERATION_LIMIT: The maximum number of iterations was reached.
  • GS_RELATIVE_TOL: The gap between the lower and upper bounds, relative to the bound with the larger magnitude, is within the user-set relative tolerance.
  • GS_ABSOLUTE_TOL: The gap between the lower and upper bounds is within the user-set absolute tolerance.
  • GS_TIME_LIMIT: The algorithm stopped after the user-specified time limit was reached.
source
EAGO.GlobalOptimizer — Type
mutable struct GlobalOptimizer{Q, S, T<:ExtensionType} <: MathOptInterface.AbstractOptimizer

Optimizer internal to EAGO which holds information used to perform branch-and-bound in order to solve nonconvex MINLPs.

Descriptions of all fields available in extended help.

Extended Help

  • _subsolvers::SubSolvers{Q, S} where {Q, S}: Storage for relaxed and upper optimizers to use, and any custom extensions

  • _parameters::EAGOParameters: Parameters that do not change during a global solve

  • _input_problem::InputProblem: Expressions and constraints added to the EAGO model (not directly used for relaxations)

  • _working_problem::ParsedProblem: Expressions and problem descriptions that EAGO uses to formulate relaxed problems

  • _auxiliary_variable_info::Union{Nothing, EAGO._AuxVarData}: Information on any auxiliary variables

  • obbt_variable_values::Vector{Bool}: Variables to perform OBBT on (default: all variables in nonlinear expressions)

  • enable_optimize_hook::Bool: Specifies that the optimize_hook! function should be called rather than throw the problem to the standard routine

  • ext::Any: (Deprecated, use _subsolvers instead) Storage for custom extension types

  • _end_state::EAGO.GlobalEndState: The completion status code for the branch-and-bound algorithm

  • _termination_status_code::MathOptInterface.TerminationStatusCode: The MathOptInterface-compliant completion status code

  • _result_status_code::MathOptInterface.ResultStatusCode: Value indicating the feasibility status of the result

  • _obj_mult::Float64: Multiplier used internally to convert objective sense from Max to Min. Only takes on values of {-1.0, 1.0}

  • _obj_var_slack_added::Bool: Flag to indicate if a slack variable was added for the objective function. This is done in some epigraph reformulations (see reform_epigraph_min!)

  • _stack::DataStructures.BinaryMinMaxHeap{NodeBB}: A heap of all nodes in the branch-and-bound tree

  • _current_node::NodeBB: The individual node being examined at any particular time. Nodes are removed from the stack and placed here, evaluated, and then sent back to the stack

  • _first_relax_point_set::Bool: (Unused) Flag for relaxation points

  • _current_xref::Vector{Float64}: (Unused) Variable values of a particular point

  • _candidate_xref::Vector{Float64}: (Unused) Variable values of a candidate point

  • _use_prior_objective_xref::Bool: (Unused) Flag to use variable values from previous evaluation on the current step

  • _current_objective_xref::Vector{Float64}: (Unused) Variable values for objective evaluation

  • _prior_objective_xref::Vector{Float64}: (Unused) Variable values for previous objective evaluation

  • _user_branch_variables::Bool: Flag for if the user has specified branch variables (see label_branch_variables!)

  • _fixed_variable::Vector{Bool}: Variables that are fixed in place

  • _branch_variable_count::Int64: Number of variables that can be branched on

  • _branch_to_sol_map::Vector{Int64}: Mapping from the branch variables to the full set of variables in the problem

  • _sol_to_branch_map::Vector{Int64}: Mapping from the full set of variables in the problem to the branch variables

  • _continuous_solution::Vector{Float64}: The final (or intermediate) variable values of the solution

  • _preprocess_feasibility::Bool: Flag to ensure preprocessing result is feasible

  • _preprocess_termination_status::MathOptInterface.TerminationStatusCode: Status codes for use in bounds tightening

  • _preprocess_primal_status::MathOptInterface.ResultStatusCode: Status codes for use in bounds tightening

  • _preprocess_dual_status::MathOptInterface.ResultStatusCode: Status codes for use in bounds tightening

  • _lower_primal_status::MathOptInterface.ResultStatusCode: Primal status of the lower problem

  • _lower_dual_status::MathOptInterface.ResultStatusCode: Dual status of the lower problem

  • _lower_termination_status::MathOptInterface.TerminationStatusCode: Termination status of the lower problem

  • _lower_feasibility::Bool: Flag for lower problem feasibility

  • _lower_objective_value::Float64: Objective value result from the lower problem

  • _lower_solution::Vector{Float64}: Variable values of the lower problem solution

  • _lower_lvd::Vector{Float64}: Lower variable duals for use in duality-based bound tightening

  • _lower_uvd::Vector{Float64}: Upper variable duals for use in duality-based bound tightening

  • _last_cut_objective::Float64: Objective value associated with the previous cut in the cutting planes algorithm

  • _upper_result_status::MathOptInterface.ResultStatusCode: Primal status of the upper problem

  • _upper_termination_status::MathOptInterface.TerminationStatusCode: Termination status of the upper problem

  • _upper_feasibility::Bool: Flag for upper problem feasibility

  • _upper_objective_value::Float64: Objective value result from the upper problem

  • _upper_variables::Vector{MathOptInterface.VariableIndex}:

  • _upper_solution::Vector{Float64}:

  • _postprocess_feasibility::Bool: (Unused) Flag to ensure postprocessing result is feasible

  • _time_left::Float64: Time remaining for the optimization algorithm. This is set in initial_parse! to the user-defined time limit and is decremented throughout global_solve!

  • _start_time::Float64: Storage for the time() when optimization began

  • _run_time::Float64: Current run time, incremented using time()-_start_time

  • _parse_time::Float64: A field to keep track of time spent on initial problem parsing

  • _presolve_time::Float64: Used in optimize_nonconvex.jl to track how long the presolve step takes

  • _last_preprocess_time::Float64: Updated each iteration to track the time of the preprocess step

  • _last_lower_problem_time::Float64: Updated each iteration to track the time of the lower problem step

  • _last_upper_problem_time::Float64: Updated each iteration to track the time of the upper problem step

  • _last_postprocessing_time::Float64: Updated each iteration to track the time of the postprocess step

  • _min_converged_value::Float64: A field to track convergence progress across iterations

  • _global_lower_bound::Float64: The best-known lower bound

  • _global_upper_bound::Float64: The best-known upper bound

  • _maximum_node_id::Int64: The total number of nodes that have been created

  • _iteration_count::Int64: The number of iterations the branch-and-bound algorithm has completed

  • _node_count::Int64: The number of nodes in the stack

  • _solution_value::Float64: (Unused) The best-known solution value

  • _feasible_solution_found::Bool: A flag for if a feasible solution was identified. Updated if preprocessing, lower problem, and upper problem all return feasible values

  • _solution_node::Int64: The node ID of the best-known feasible upper problem solution (default = -1, if no feasible solution is found)

  • _best_upper_value::Float64: The best-known upper bound

  • _obbt_working_lower_index::Vector{Bool}: Indices of variables to perform OBBT on

  • _obbt_working_upper_index::Vector{Bool}: Indices of variables to perform OBBT on

  • _lower_indx_diff::Vector{Bool}: Tracker for changes in obbtworkinglowerindex across iterations

  • _upper_indx_diff::Vector{Bool}: Tracker for changes in obbtworkingupperindex across iterations

  • _old_low_index::Vector{Bool}: Storage for indices prior to OBBT step

  • _old_upp_index::Vector{Bool}: Storage for indices prior to OBBT step

  • _new_low_index::Vector{Bool}: New indices following OBBT step; compared with _old_low_index

  • _new_upp_index::Vector{Bool}: New indices following OBBT step; compared with _old_upp_index

  • _obbt_variables::Vector{MathOptInterface.VariableIndex}: (Deprecated) Variables to perform OBBT on. Replaced by _obbt_working_lower_index and _obbt_working_upper_index

  • _obbt_variable_count::Int64: The number of variables to perform OBBT on

  • _obbt_performed_flag::Bool: (Unused) Flag to indicate whether OBBT has been performed

  • _lower_fbbt_buffer::Vector{Float64}: Buffer for FBBT lower bounds. Set in presolve, used in preprocess

  • _upper_fbbt_buffer::Vector{Float64}: Buffer for FBBT upper bounds. Set in presolve, used in preprocess

  • _cp_improvement::Float64: (Unused) Improvement in constraint propagation

  • _cp_evaluation_reverse::Bool: (Unused) Flag for if constraint propagation results need to be reversed

  • _cut_iterations::Int64: Iterations of the cutting planes algorithm completed

  • _cut_add_flag::Bool: (Unused) Flag to check if cuts should be added

  • _node_repetitions::Int64: Counter for number of times a node is evaluated. If the repeat_check function is overloaded to return true, a node will not be branched on, but will instead be added back into the stack using single_storage!. In this case, _node_repetitions is incremented

  • _log::Log: Storage for logging information during a branch-and-bound run

  • _affine_relax_ci::Vector{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}}: Storage for affine constraints

  • _affine_objective_cut_ci::Union{Nothing, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}}: Storage for a linear objective cut constraint

  • _relaxed_variable_number::Int64: (Unused) Number of relaxed variables

  • _relaxed_variable_index::Vector{MathOptInterface.VariableIndex}: Indices of relaxed variables

  • _relaxed_variable_et::Vector{Tuple{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.EqualTo{Float64}}, Int64}}: Stored EqualTo constraints

  • _relaxed_variable_lt::Vector{Tuple{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}, Int64}}: Stored LessThan constraints

  • _relaxed_variable_gt::Vector{Tuple{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}, Int64}}: Stored GreaterThan constraints

  • _relaxed_variable_integer::Vector{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.Integer}}: Stored Integer constraints

  • _branch_variables::Vector{Bool}: List of variables that can be branched on. If not user-specified, branch variables are identified in label_branch_variables!

  • _nonbranching_int::Bool: (Unused) Flag for non-branching integers

  • _new_eval_constraint::Bool: Flag indicating if an initial evaluation of the constraints has occurred

  • _new_eval_objective::Bool: Flag indicating if the objective expression was evaluated

  • _node_to_sv_leq_ci::Dict{Int64, MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}}: Storage for carrying LessThan constraint information. Used in obbt! and update_relaxed_problem_box!

  • _node_to_sv_geq_ci::Dict{Int64, MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}}: Storage for carrying GreaterThan constraint information. Used in obbt! and update_relaxed_problem_box!

  • _nonlinear_evaluator_created::Bool: Flag to check for nonlinear evaluators. Set to true in add_nonlinear_evaluator!

  • _branch_cost::EAGO.BranchCostStorage{Float64}: (FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED) Storage for pseudocost branching

  • _branch_variable_sparsity::SparseArrays.SparseMatrixCSC{Bool, Int64}: (FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED) Sparsity information of the branch variables

  • _constraint_infeasiblity::Vector{Float64}: (FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED) Information on the infeasibility of each constraint

source
EAGO.Incremental — Type
mutable struct Incremental{S<:MathOptInterface.AbstractOptimizer} <: MathOptInterface.AbstractOptimizer

A type-stable cache used to wrapper for an optimizer that enables incremental modification of solvers that don't inherently suppport this. Explicitly checks support of MOI functionality used in EAGO.

(Deprecated) For Q = Val{true}, the subsolver supports incremental loading. For Q = Val{false}, the subsolver does not.

source
EAGO.InputProblem — Type
mutable struct InputProblem

A structure used to hold objectives and constraints added to the EAGO model. The constraints generally aren't used for relaxations.

All field information available in extended help.

Extended Help

  • _variable_count::Int64: Count for the number of variables

  • _variable_names::Dict{MathOptInterface.VariableIndex, String}: Dictionary containing variable indices and their names

  • _constraint_count::Int64: Count for the number of constraints

  • _vi_leq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}}

  • _vi_geq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}}

  • _vi_eq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.EqualTo{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.EqualTo{Float64}}}

  • _vi_it_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.Interval{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.Interval{Float64}}}

  • _vi_zo_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.ZeroOne}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.ZeroOne}}

  • _vi_int_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.Integer}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.Integer}}

  • _linear_leq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, Tuple{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}}

  • _linear_geq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Tuple{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}

  • _linear_eq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Tuple{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}}

  • _quadratic_leq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}, Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}}

  • _quadratic_geq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}

  • _quadratic_eq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}}

  • _conic_second_order::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VectorOfVariables, MathOptInterface.SecondOrderCone}, Tuple{MathOptInterface.VectorOfVariables, MathOptInterface.SecondOrderCone}}

  • _linear_leq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, Float64}

  • _linear_geq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Float64}

  • _linear_eq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Float64}

  • _quadratic_leq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}, Float64}

  • _quadratic_geq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Float64}

  • _quadratic_eq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Float64}

  • _linear_leq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}}

  • _linear_geq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}

  • _linear_eq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}}

  • _quadratic_leq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}}

  • _quadratic_geq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}

  • _quadratic_eq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}}

  • _objective::Union{Nothing, MathOptInterface.VariableIndex, MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.ScalarQuadraticFunction{Float64}}: Storage for the objective function

  • _nlp_data::Union{Nothing, MathOptInterface.NLPBlockData}: Storage for NLP constraints (set by MOI.set(m, ::NLPBlockData...) in moi_wrapper.jl)

  • _optimization_sense::MathOptInterface.OptimizationSense: Objective sense information (set by MOI.set(m, ::ObjectiveSense...))

source
EAGO.LocalResultStatus — Type
LocalResultStatus

Status code used internally to determine how to interpret the results from the solution of a local problem solve.

source
EAGO.Log — Type
mutable struct Log

A structure used to store information on the history of the solution procedure for generating convergence plots and other analyses.

  • current_lower_bound::Vector{Float64}: Storage for lower bound calculated for current node.

  • current_upper_bound::Vector{Float64}: Storage for upper bound calculated for current node.

  • preprocessing_time::Vector{Float64}: Storage for preprocessing time of each iteration.

  • lower_problem_time::Vector{Float64}: Storage for lower bounding time of each iteration.

  • upper_problem_time::Vector{Float64}: Storage for upper bounding time of each iteration.

  • postprocessing_time::Vector{Float64}: Storage for postprocessing time of each iteration.

  • preprocessing_feas::Vector{Bool}: Storage for preprocessing feasibility of each iteration.

  • lower_problem_feas::Vector{Bool}: Storage for lower bounding feasibility of each iteration.

  • upper_problem_feas::Vector{Bool}: Storage for upper bounding feasibility of each iteration.

  • postprocessing_feas::Vector{Bool}: Storage for postprocessing feasibility of each iteration.

  • global_lower_bound::Vector{Float64}: Storage for best (global) lower bound at each iteration.

  • global_upper_bound::Vector{Float64}: Storage for best (global) upper bound at each iteration.

  • node_count::Vector{Int64}: Number of nodes at each iteration.

  • run_time::Vector{Float64}: Run time at each iteration.

source
EAGO.Node — Type
struct Node <: EAGO.AbstractNode

Describes connectivity and expression represented by node.

source
EAGO.NodeBB — Type
struct NodeBB

Store information associated with each node in the branch-and-bound tree.

  • lower_variable_bounds::Vector{Float64}: Lower bounds of variable box.

  • upper_variable_bounds::Vector{Float64}: Upper bounds of variable box.

  • is_integer::BitVector: Is dimension integer valued

  • continuous::Bool: Are all dimensions continuous (or fixed)

  • lower_bound::Float64: Lower bound of problem solution on nodeBB

  • upper_bound::Float64: Upper bound of problem solution on nodeBB

  • depth::Int64: Depth of node in B&B tree.

  • cont_depth::Int64: Depth of first parent in B&B tree that was continuously valued

  • id::Int64: Unique ID for each node.

  • branch_direction::EAGO.BranchDirection: Whether last branch was negative or positive in direction

  • last_branch::Int64: Dimension of last branch

  • branch_extent::Float64: Extent of last branch (using for psuedocost calculation)

source
EAGO.NodeClass — Type
NodeType

Each node in the directed graph can be classified into the following types

  • VARIABLE: Denotes a decision variable.
  • PARAMETER: An adjustable parameter value (not a decision variable).
  • CONSTANT: A constant value
  • EXPRESSION: Any other expression that isn't a subexpression
  • SUBEXPRESSION: Any expression referencing a different graph representation.
source
EAGO.NonlinearExpression — Type
mutable struct NonlinearExpression{V, N, T<:RelaxTag} <: EAGO.AbstractEAGOConstraint

Stores a general quadratic function with a buffer.

source
EAGO.Optimizer — Type
mutable struct Optimizer{Q, S, T} <: MathOptInterface.AbstractOptimizer

The highest level optimizer object used by EAGO to solve problems during the optimization routine. Additional options and temporary storage are located in the _global_optimizer::GlobalOptimizer{Q,S,T} field. Parameters which are expected to be constant over the entire solve are stored in the _parameters::EAGOParameters field. Some user-facing keywords not in the EAGOParameters field include:

  • relaxed_optimizer::MOI.AbstractOptimizer: An instance of the optimizer used to solve the relaxed subproblems (default = Cbc.Optimizer()). Located in subsolver_block::SubSolvers{Q,S,T}.
  • upper_optimizer::MOI.AbstractOptimizer: Optimizer used to solve upper bounding problems (default = Ipopt.Optimizer()). Located in subsolver_block::SubSolvers{Q,S,T}.
  • ext::ExtensionType: Holds an instance of a subtype of EAGO.ExtensionType, used to define new custom subroutines (default = DefaultExt()). Located in subsolver_block::SubSolvers{Q,S,T}.
  • enable_optimize_hook::Bool: Specifies that the user-defined optimize_hook! function should be called rather than use the standard EAGO optimization routines. Located in Optimizer and _global_optimizer::GlobalOptimizer{Q,S,T}.
  • obbt_variable_values::Vector{Bool}: Variables to perform OBBT on (default: all variables in nonlinear expressions). Located in _global_optimizer::GlobalOptimizer{Q,S,T}.

Descriptions of all Optimizer fields available in extended help.

Extended Help

  • subsolver_block::SubSolvers{Q, S, T} where {Q, S, T}: Holds definitions of the relaxed and upper optimizers, as well as any user-defined extension types

  • enable_optimize_hook::Bool: Specifies that the optimize_hook! function should be called rather than throw the problem to the standard routine

  • ext::Union{Nothing, T} where T: (Deprecated, use subsolver_block instead) Storage for custom extension types

  • _auxiliary_variable_info::Union{Nothing, EAGO._AuxVarData}: Information on any auxiliary variables

  • _global_optimizer::GlobalOptimizer{Q, S, T} where {Q, S, T}: Additional options and temporary storage for solving optimization problems

  • _input_problem::InputProblem: Expressions and constraints added to the EAGO model (not directly used for relaxations)

  • _working_problem::ParsedProblem: Expressions and problem descriptions that EAGO uses to formulate relaxed problems

  • _parameters::EAGOParameters: Parameters that do not change during a global solve

  • _optimizer_attributes_set::Vector{MathOptInterface.AbstractOptimizerAttribute}: Set of optimizer attributes

  • _termination_status_code::MathOptInterface.TerminationStatusCode: The MathOptInterface-compliant completion status code

  • _result_status_code::MathOptInterface.ResultStatusCode: Value indicating the feasibility status of the result

  • _run_time::Float64: Optimization run time

  • _objective_value::Float64: The objective value of the primal solution

  • _objective_bound::Float64: The best-known bound on the optimal objective value

  • _relative_gap::Float64: The gap between the upper and lower bound, relative to the bound with the larger magnitude

  • _iteration_count::Int64: The number of iterations the branch-and-bound algorithm has completed

  • _node_count::Int64: The number of nodes in the stack

source
EAGO.ParsedProblem — Type
mutable struct ParsedProblem

A structure used to store expressions and problem descriptions EAGO uses to formulate relaxed problems.

All field information available in extended help.

Extended Help

  • _problem_type::Union{Nothing, EAGO.DIFF_CVX, EAGO.LP, EAGO.MILP, EAGO.MINCVX, EAGO.MISOCP, EAGO.SOCP}: Problem classification (set in parse_classify_problem!)

  • _objective_saf::MathOptInterface.ScalarAffineFunction{Float64}: Stores the objective and is used for constructing linear affine cuts

  • _objective::Union{Nothing, MathOptInterface.VariableIndex, EAGO.AffineFunctionIneq, EAGO.BufferedQuadraticIneq, EAGO.BufferedNonlinearFunction}: Storage for the objective function

  • _optimization_sense::MathOptInterface.OptimizationSense: Objective sense information (set by MOI.set(m, ::ObjectiveSense...))

  • _saf_leq::Vector{EAGO.AffineFunctionIneq}

  • _saf_eq::Vector{EAGO.AffineFunctionEq}

  • _sqf_leq::Vector{EAGO.BufferedQuadraticIneq}

  • _sqf_eq::Vector{EAGO.BufferedQuadraticEq}

  • _conic_second_order::Vector{EAGO.BufferedSOC}

  • _nlp_data::Union{Nothing, MathOptInterface.NLPBlockData}

  • _nonlinear_constr::Vector{EAGO.BufferedNonlinearFunction}

  • _relaxed_evaluator::Evaluator

  • _variable_info::Vector{VariableInfo{Float64}}: Variable information (set in initial_parse!)

  • _variable_count::Int64: Count for the number of variables

source
EAGO.RelaxResultStatus — Type
RelaxResultStatus

Status code used internally to determine how to interpret the results from the solution of a relaxed problem.

source
EAGO.SIPHybrid — Type
SIPHybrid

Specifies that the SIPHybrid algorithm which implements Algorithm #2 of Djelassi, Hatim, and Alexander Mitsos. "A hybrid discretization algorithm with guaranteed feasibility for the global solution of semi-infinite programs." Journal of Global Optimization 68.2 (2017): 227-253 should be used.

source
EAGO.SIPRes — Type
SIPRes

Specifies that the SIPRes algorithm which implements Algorithm #1 of Djelassi, Hatim, and Alexander Mitsos. "A hybrid discretization algorithm with guaranteed feasibility for the global solution of semi-infinite programs." Journal of Global Optimization 68.2 (2017): 227-253 should be used.

source
EAGO.SIPResRev — Type
SIPResRev

Specifies that the SIPResRev algorithm which implements Algorithm #1 of Djelassi, Hatim, and Alexander Mitsos. "A hybrid discretization algorithm with guaranteed feasibility for the global solution of semi-infinite programs." Journal of Global Optimization 68.2 (2017): 227-253 should be used.

source
EAGO.SIPSubResult — Type
SIPBuffer

Hold objective value, solution, discretization set, and feasibility status of each subproblem encountered by SIP algorithm.

source
EAGO.SubSolvers — Type
mutable struct SubSolvers{Q<:MathOptInterface.AbstractOptimizer, S<:MathOptInterface.AbstractOptimizer, T<:ExtensionType}

A structure containing the relaxed and upper optimizers to be used, as well as any user-defined extension.

  • relaxed_optimizer::MathOptInterface.AbstractOptimizer: Optimizer used to solve relaxed subproblems. Set using r = [...] (<: MOI.AbstractOptimizer) (default = Cbc.Optimizer())

  • upper_optimizer::MathOptInterface.AbstractOptimizer: Optimizer used to solve upper bounding problems. Set using u = [...] (<: MOI.AbstractOptimizer) (default = Ipopt.Optimizer())

  • ext::ExtensionType: User-defined extension to use. Set using t = [...](<: EAGO.ExtensionType)

source
EAGO.VariableInfo — Type
struct VariableInfo{T<:AbstractFloat}

A structure used to store information related to the bounds assigned to each variable.

  • is_integer::Bool: Is the variable integer valued?

  • has_lower_bound::Bool: Boolean indicating whether a finite lower bound exists.

  • has_upper_bound::Bool: Boolean indicating whether a finite upper bound exists.

  • is_fixed::Bool: Boolean indicating if variable is fixed to a finite value.

  • has_constraints::Bool: Boolean indicating that constraints have been set

  • lower_bound::AbstractFloat: Lower bound. May be -Inf.

  • upper_bound::AbstractFloat: Upper bound. May be Inf.

source