diff --git a/dev/.documenter-siteinfo.json b/dev/.documenter-siteinfo.json index 66113247..d9bc2d61 100644 --- a/dev/.documenter-siteinfo.json +++ b/dev/.documenter-siteinfo.json @@ -1 +1 @@ -{"documenter":{"julia_version":"1.9.3","generation_timestamp":"2023-11-06T22:35:09","documenter_version":"1.1.2"}} \ No newline at end of file +{"documenter":{"julia_version":"1.9.3","generation_timestamp":"2023-11-07T20:51:49","documenter_version":"1.1.2"}} \ No newline at end of file diff --git a/dev/cite/index.html b/dev/cite/index.html index f2b9f4b6..a2fd4a8c 100644 --- a/dev/cite/index.html +++ b/dev/cite/index.html @@ -1,3 +1,3 @@ Citing EAGO · EAGO.jl
GitHub

Citing EAGO

Please cite the following paper when using EAGO.jl:

Wilhelm, M.E. and Stuber, M.D. EAGO.jl: easy advanced global optimization in Julia.
-Optimization Methods and Software. 37(2): 425-450 (2022). DOI: 10.1080/10556788.2020.1786566
+Optimization Methods and Software. 37(2): 425-450 (2022). DOI: 10.1080/10556788.2020.1786566 diff --git a/dev/custom_guidelines/index.html b/dev/custom_guidelines/index.html index 16496dd7..74759509 100644 --- a/dev/custom_guidelines/index.html +++ b/dev/custom_guidelines/index.html @@ -31,4 +31,4 @@ x._result_status_code = MathOptInterface.FEASIBLE_POINT end return flag -end

References

  1. Kelley, J. E. “The Cutting-Plane Method for Solving Convex Programs.” Journal of the Society for Industrial and Applied Mathematics, vol. 8, no. 4, pp. 703–12 (1960).
  2. Tawarmalani, M., Sahinidis, N. V. "Global optimization of mixed-integer nonlinear programs: A theoretical and computational study." Math. Program., Ser. A, 99, pp. 563-591 (2004).
+end

References

  1. Kelley, J. E. “The Cutting-Plane Method for Solving Convex Programs.” Journal of the Society for Industrial and Applied Mathematics, vol. 8, no. 4, pp. 703–12 (1960).
  2. Tawarmalani, M., Sahinidis, N. V. "Global optimization of mixed-integer nonlinear programs: A theoretical and computational study." Math. Program., Ser. A, 99, pp. 563-591 (2004).
diff --git a/dev/dev/api_functions/index.html b/dev/dev/api_functions/index.html index f22ebe59..68a1fb4c 100644 --- a/dev/dev/api_functions/index.html +++ b/dev/dev/api_functions/index.html @@ -5,150 +5,150 @@ _::Type{F}, _::Type{S} ) -

Add a constraint to the local problem, storing the new constraint index and the associated index in the input problem.

source
EAGO._add_constraint_store_ci_linear! — Method
_add_constraint_store_ci_linear!(d, ip::InputProblem)
-

Add linear constraints to the local problem, storing the new constraint indices and the associated indices in the input problem.

source
EAGO._add_constraint_store_ci_quadratic! — Method
_add_constraint_store_ci_quadratic!(d, ip::InputProblem)
-

Add quadratic constraints to the local problem, storing the new constraint indices and the associated indices in the input problem.

source
EAGO._bvi — Method
_bvi(m::GlobalOptimizer, i::Int64) -> Int64
-

Return the branch-to-sol mapping for the i'th variable.

source
EAGO._constraint_primal — Method
_constraint_primal

Helper function which simplifies finding constraints of different types. See also: _constraints

source
EAGO._constraints — Method
_constraints

Helper function which simplifies finding constraints of different types. See also: _constraint_primal

source
EAGO._diam — Method
_diam(::BranchVar, ::GlobalOptimizer, ::Int)
-_diam(::FullVar, ::GlobalOptimizer, ::Int)

Return the diameter of a variable (upper bound - lower bound).

source
EAGO._ext — Method
_ext(::Optimizer)
+

Add a constraint to the local problem, storing the new constraint index and the associated index in the input problem.

source
EAGO._add_constraint_store_ci_linear! — Method
_add_constraint_store_ci_linear!(d, ip::InputProblem)
+

Add linear constraints to the local problem, storing the new constraint indices and the associated indices in the input problem.

source
EAGO._add_constraint_store_ci_quadratic! — Method
_add_constraint_store_ci_quadratic!(d, ip::InputProblem)
+

Add quadratic constraints to the local problem, storing the new constraint indices and the associated indices in the input problem.

source
EAGO._bvi — Method
_bvi(m::GlobalOptimizer, i::Int64) -> Int64
+

Return the branch-to-sol mapping for the i'th variable.

source
EAGO._constraint_primal — Method
_constraint_primal

Helper function which simplifies finding constraints of different types. See also: _constraints

source
EAGO._constraints — Method
_constraints

Helper function which simplifies finding constraints of different types. See also: _constraint_primal

source
EAGO._diam — Method
_diam(::BranchVar, ::GlobalOptimizer, ::Int)
+_diam(::FullVar, ::GlobalOptimizer, ::Int)

Return the diameter of a variable (upper bound - lower bound).

source
EAGO._ext — Method
_ext(::Optimizer)
 _ext(::GlobalOptimizer)
-_ext(::SubSolvers)

Return the extension (<: ExtensionType) from the SubSolvers (sub)field or object.

source
EAGO._extract_primal! — Method
_extract_primal!(d, m::InputProblem, _::Type{F}, _::Type{S})
-

Extract primal constraint value from the local problem and save the result to the appropriate field of the optimizer.

source
EAGO._extract_primal_linear! — Method
_extract_primal_linear!(d, ip::InputProblem)
-

Extract linear primal constraint values from the local problem and save the result to the appropriate field of the optimizer.

source
EAGO._extract_primal_quadratic! — Method
_extract_primal_quadratic!(d, ip::InputProblem)
-

Extract quadratic primal constraint values from the local problem and save the result to the appropriate field of the optimizer.

source
EAGO._is_branch_var — Method
_is_branch_var(m::GlobalOptimizer, i) -> Any
-

Check if m._branch_variables[i] is true or false.

source
EAGO._is_input_min — Method
_is_input_min(m::GlobalOptimizer) -> Bool
-

Check to see if the sense of the optimization problem is Min (true) or Max (false).

source
EAGO._relaxed_optimizer — Method
_relaxed_optimizer(::GlobalOptimizer)
-_relaxed_optimizer(::SubSolvers)

Return the relaxed optimizer (<: MOI.AbstractOptimizer) from the SubSolvers field or object.

source
EAGO._svi — Method
_svi(m::GlobalOptimizer, i::Int64) -> Int64
-

Return the sol-to-branch mapping for the i'th variable.

source
EAGO._upper_optimizer — Method
_upper_optimizer(::GlobalOptimizer)
-_upper_optimizer(::SubSolvers)

Return the upper optimizer (<: MOI.AbstractOptimizer) from the SubSolvers field or object.

source
EAGO.add_nonlinear! — Method
add_nonlinear!(m::GlobalOptimizer)
-

Add an Evaluator and nonlinear functions and populate each appropriately.

source
EAGO.add_nonlinear_evaluator! — Method
add_nonlinear_evaluator!

Add an Evaluator structure if nonlinear terms are attached.

source
EAGO.add_objective! — Method
add_objective!

Add objective function (if any) to the parsed problem.

source
EAGO.affine_relax_quadratic! — Method
affine_relax_quadratic!

Default routine for relaxing quadratic constraint func < 0.0 on node n. Takes affine bounds of convex part at point x0 and secant line bounds on concave parts.

source
EAGO.aggressive_filtering! — Method
aggressive_filtering!(
+_ext(::SubSolvers)

Return the extension (<: ExtensionType) from the SubSolvers (sub)field or object.

source
EAGO._extract_primal! — Method
_extract_primal!(d, m::InputProblem, _::Type{F}, _::Type{S})
+

Extract primal constraint value from the local problem and save the result to the appropriate field of the optimizer.

source
EAGO._extract_primal_linear! — Method
_extract_primal_linear!(d, ip::InputProblem)
+

Extract linear primal constraint values from the local problem and save the result to the appropriate field of the optimizer.

source
EAGO._extract_primal_quadratic! — Method
_extract_primal_quadratic!(d, ip::InputProblem)
+

Extract quadratic primal constraint values from the local problem and save the result to the appropriate field of the optimizer.

source
EAGO._is_branch_var — Method
_is_branch_var(m::GlobalOptimizer, i) -> Any
+

Check if m._branch_variables[i] is true or false.

source
EAGO._is_input_min — Method
_is_input_min(m::GlobalOptimizer) -> Bool
+

Check to see if the sense of the optimization problem is Min (true) or Max (false).

source
EAGO._relaxed_optimizer — Method
_relaxed_optimizer(::GlobalOptimizer)
+_relaxed_optimizer(::SubSolvers)

Return the relaxed optimizer (<: MOI.AbstractOptimizer) from the SubSolvers field or object.

source
EAGO._svi — Method
_svi(m::GlobalOptimizer, i::Int64) -> Int64
+

Return the sol-to-branch mapping for the i'th variable.

source
EAGO._upper_optimizer — Method
_upper_optimizer(::GlobalOptimizer)
+_upper_optimizer(::SubSolvers)

Return the upper optimizer (<: MOI.AbstractOptimizer) from the SubSolvers field or object.

source
EAGO.add_nonlinear! — Method
add_nonlinear!(m::GlobalOptimizer)
+

Add an Evaluator and nonlinear functions and populate each appropriately.

source
EAGO.add_nonlinear_evaluator! — Method
add_nonlinear_evaluator!

Add an Evaluator structure if nonlinear terms are attached.

source
EAGO.add_objective! — Method
add_objective!

Add objective function (if any) to the parsed problem.

source
EAGO.affine_relax_quadratic! — Method
affine_relax_quadratic!

Default routine for relaxing quadratic constraint func < 0.0 on node n. Takes affine bounds of convex part at point x0 and secant line bounds on concave parts.

source
EAGO.aggressive_filtering! — Method
aggressive_filtering!(
     m::GlobalOptimizer{R, S, Q<:ExtensionType},
     n::NodeBB
 ) -> Bool
-

Excludes OBBT on variable indices after a search in a filtering direction.

source
EAGO.bool_indx_diff! — Method
bool_indx_diff!(
+

Excludes OBBT on variable indices after a search in a filtering direction.

source
EAGO.bool_indx_diff! — Method
bool_indx_diff!(
     z::Vector{Bool},
     x::Vector{Bool},
     y::Vector{Bool}
 ) -> Vector{Bool}
-

Utility function used to set vector of booleans z to x & ~y. Avoids the generation of conversion of the BitArray created by broadcasting logical operators.

source
EAGO.bound_objective — Method
bound_objective(::GlobalOptimizer, ::T)
-bound_objective(::ExtensionType, ::GlobalOptimizer)

Compute a tuple representing the lower and upper bounds for an objective function. Note: bound_objective(::GlobalOptimizer) dispatches to bound_objective(::ExtensionType, ::GlobalOptimizer).

Options for T:

  • AffineFunctionIneq
  • BufferedNonlinearFunction
  • BufferedQuadraticIneq
  • MOI.VariableIndex
source
EAGO.branch_node! — Method
branch_node!(t::ExtensionType, m::GlobalOptimizer)
-

Create two nodes from current_node and store them on the stack. Call select_branch_variable(t, m) and select_branch_point(t, m, k) to determine the variable that should be branched on and the point at which branching should occur, respectively.

source
EAGO.build_model — Method
build_model

Create the model and variables used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command build_model(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, p::SIPProblem).

source
EAGO.check_set_affine_nl! — Method
check_set_affine_nl!(
+

Utility function used to set vector of booleans z to x & ~y. Avoids the generation of conversion of the BitArray created by broadcasting logical operators.

source
EAGO.bound_objective — Method
bound_objective(::GlobalOptimizer, ::T)
+bound_objective(::ExtensionType, ::GlobalOptimizer)

Compute a tuple representing the lower and upper bounds for an objective function. Note: bound_objective(::GlobalOptimizer) dispatches to bound_objective(::ExtensionType, ::GlobalOptimizer).

Options for T:

  • AffineFunctionIneq
  • BufferedNonlinearFunction
  • BufferedQuadraticIneq
  • MOI.VariableIndex
source
EAGO.branch_node! — Method
branch_node!(t::ExtensionType, m::GlobalOptimizer)
+

Create two nodes from current_node and store them on the stack. Call select_branch_variable(t, m) and select_branch_point(t, m, k) to determine the variable that should be branched on and the point at which branching should occur, respectively.

source
EAGO.build_model — Method
build_model

Create the model and variables used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command build_model(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, p::SIPProblem).

source
EAGO.check_set_affine_nl! — Method
check_set_affine_nl!(
     m::GlobalOptimizer{R, S, Q<:ExtensionType},
     f::EAGO.BufferedNonlinearFunction{V, N, T<:RelaxTag},
     finite_cut::Bool,
     check_safe::Bool
 ) -> Bool
-
source
EAGO.convergence_check — Method
convergence_check(
+
source
EAGO.convergence_check — Method
convergence_check(
     t::ExtensionType,
     m::GlobalOptimizer
 ) -> Bool
-

Check for problem convergence.

By default, check if the lower and upper bounds have converged to within absolute and/or relative tolerances.

source
EAGO.create_buffer_dict — Method
create_buffer_dict(
+

Check for problem convergence.

By default, check if the lower and upper bounds have converged to within absolute and/or relative tolerances.

source
EAGO.create_buffer_dict — Method
create_buffer_dict(
     func::MathOptInterface.ScalarQuadraticFunction{Float64}
 ) -> Dict{Int64, Float64}
-

Create a buffer dictionary from a ScalarQuadraticFunction.

source
EAGO.cut — Method

cut

Intersects the new set valued operator with the prior and performs affine bound tightening

  • First forward pass: post should be set by user option, is_intersect should be false so that the tape overwrites existing values, and the interval_intersect flag could be set to either value.
  • Forward CP pass (assumes same reference point): post should be set by user option, is_intersect should be true so that the tape intersects with existing values, and the interval_intersect flag should be false.
  • Forward CP pass (assumes same reference point): post should be set by user option, is_intersect should be true so that the tape intersects with existing values, and the interval_intersect flag should be false.
  • Subsequent forward passes at new points: postshould be set by user option,isintersectshould be true so that the tape intersects with existing values, and theintervalintersectflag should betrue` as predetermined interval bounds are valid but the prior values may correspond to different points of evaluation.
source
EAGO.cut_condition — Method
cut_condition(t::ExtensionType, m::GlobalOptimizer) -> Bool
-

Returns true if a cut should be added and computes a new reference point to add the cut at. By default, checks that cut_max_iterations are not exceeded and that the improvement in the objective value associated with the previous cut is greater than both an absolute tolerance cut_ϵ_abs and a relative tolerance cut_ϵ_rel. Returns false otherwise.

source
EAGO.default_upper_heuristic — Method
default_upper_heuristic(m::GlobalOptimizer) -> Bool
-

Default check to see if the upper bounding problem should be run. By default, The upper bounding problem is run on every node up to depth upper_bounding_depth and is triggered with a probability of 0.5^(depth - upper_bounding_depth) afterwards for continuous problems. For integral problems, the upper_bounding_depth approach is used as well as running on every node up to depth upper_bounding_depth + cont_depth with another trigger of probability 0.5^(depth - upper_bounding_depth - cont_depth).

source
EAGO.diam — Method

Return the diameter of a variable (upper bound - lower bound).

source
EAGO.eliminate_fixed_variables! — Function
eliminate_fixed_variables!(::T, ::Vector{VariableInfo})

Eliminate fixed variables by rearrangment or restructuring of the AbstractEAGOConstraint.

Options for T (all are subtypes of AbstractEAGOConstraint):

  • AffineFunctionEq
  • AffineFunctionIneq
  • BufferedQuadraticIneq
  • BufferedNonlinearFunction{N,T} where {N, T<:RelaxTag}
  • NonlinearExpression{V,N,T} where {V, N, T<:RelaxTag}
source
EAGO.f_init! — Method

Initializes information in cache c for each node in g that may be used in a forward-pass of attribute t.

source
EAGO.fathom! — Method
fathom!(t::ExtensionType, m::GlobalOptimizer)
-

Remove nodes from the stack. By default, delete nodes from the stack if their lower bounds are greater than the current global upper bound.

source
EAGO.fbbt! — Function
fbbt!(m::GlobalOptimizer, f::T)

Performs feasibility-based bound tightening on a back-end constraint and returns true if it is feasible or false if it is infeasible.

Options for T (all are subtypes of AbstractEAGOConstraint):

  • AffineFunctionIneq
  • AffineFunctionEq
source
EAGO.fprop! — Method

Populates information associated with attribute t for a constant v at index k in cache c associated with graph g using information at index k.

source
EAGO.fprop! — Method

Populates information associated with attribute t for a expression v at index k in cache c associated with graph g using information taken from the children of k.

source
EAGO.fprop! — Method

Populates information associated with attribute t for a parameter v at index k in cache c associated with graph g using information at index k.

source
EAGO.fprop! — Method

Populates information associated with attribute t for a subexpression v at index k in cache c associated with graph g using information taken from the children of k.

source
EAGO.fprop! — Method

Populates information associated with attribute t for a variable v at index k in cache c associated with graph g using information at index k.

source
EAGO.get_sip_optimizer — Method
get_sip_optimizer

Specifices the optimizer to be used in extension t::EAGO.ExtensionType with algorithm alg::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command get_sip_optimizer(t::ExtensionType, alg::AbstractSIPAlgo, s::AbstractSubproblemType).

source
EAGO.global_solve! — Method
global_solve!(m::GlobalOptimizer)
-

Solves the branch-and-bound problem with the input EAGO.GlobalOptimizer object.

Pseudocode description of the algorithm, as implemented here:

-I) Prepare optimizers and stack for branch-and-bound

-II) While no reason to terminate the algorithm has occurred:

–-II.A) Fathom nodes from the stack

–-II.B) Select the new "current node" from the stack

–-II.C) Perform preprocessing on current node

–-II.D) If preprocessing result is feasible:

––-II.D.1) Solve lower problem for current node

––-II.D.2) If lower problem result is feasible and lower/upper bounds have not converged:

–––-II.D.2.a) Solve upper problem for current node

–––-II.D.2.b) Update the global upper bound if necessary

–––-II.D.2.c) Perform postprocessing

–––-II.D.2.d) If postprocessing result is feasible:

––––-II.D.2.d.α) Branch and add the nodes back to the stack

–-II.E) Update the global lower bound if necessary

–-II.F) Update log information

-III) Set termination and result statuses

-IV) Print solution

source
EAGO.initial_parse! — Method
initial_parse!(m::Optimizer{R, S, T})
-

Translate the input problem to the working problem. Any checks or optional manipulation are left to the presolve stage.

source
EAGO.initialize! — Method
initialize!(_::AbstractCache, _::AbstractDirectedGraph)
-

Function used to initialize the storage cache d::AbstractCache for a given type of directed acyclic graph g::AbstractDirectedGraph.

source
EAGO.initialize_stack! — Method
initialize_stack!(t::ExtensionType, m::GlobalOptimizer)
-

Prepare the stack for the branch-and-bound routine. By default, create an initial node with the variable bounds as box constraints and add it to the stack.

source
EAGO.interval_bound — Function
interval_bound(::GlobalOptimizer, ::T)

Compute a tuple representing the lower and upper interval bounds for an AbstractEAGOConstraint representing an equality constraint.

Options for T (all are subtypes of AbstractEAGOConstraint):

  • AffineFunctionEq
  • AffineFunctionIneq
  • BufferedQuadraticEq
  • BufferedQuadraticIneq
  • BufferedNonlinearFunction{V,N,T} where {V,N,T}
source
EAGO.interval_objective_bound! — Function
source
EAGO.is_feasible — Method
is_feasible(::GlobalOptimizer, ::T)

Check if a given bound is feasible.

Options for T (all are subtypes of AbstractEAGOConstraint):

  • AffineFunctionIneq
  • AffineFunctionEq
  • BufferedQuadraticIneq
  • BufferedQuadraticEq
  • BufferedNonlinearFunction{V,N,T}
source
EAGO.is_integer_feasible_local — Method
is_integer_feasible_local(m::GlobalOptimizer, d) -> Bool
-

Checks that the solution of a local solve is integer feasible to within the tolerances specified by integer_abs_tol and integer_rel_tol.

source
EAGO.is_integer_feasible_relaxed — Method
is_integer_feasible_relaxed(m::GlobalOptimizer) -> Bool
-

Check that the solution of the lower (relaxed problem) is integer feasible to within tolerances specified by the parameters: integer_abs_tol (absolute tolerance) and integer_rel_tol (relative tolerance).

source
EAGO.is_integer_subproblem — Method
is_integer_subproblem(m)
-

Returns true that the subproblem at the current node n has participating integer variables that have not been fixed to constant valued as the branch-and-bound algorithm progresses. Returns false otherwise.

source
EAGO.is_safe_cut! — Method
is_safe_cut!(
+

Create a buffer dictionary from a ScalarQuadraticFunction.

source
EAGO.cut — Method

cut

Intersects the new set valued operator with the prior and performs affine bound tightening

  • First forward pass: post should be set by user option, is_intersect should be false so that the tape overwrites existing values, and the interval_intersect flag could be set to either value.
  • Forward CP pass (assumes same reference point): post should be set by user option, is_intersect should be true so that the tape intersects with existing values, and the interval_intersect flag should be false.
  • Forward CP pass (assumes same reference point): post should be set by user option, is_intersect should be true so that the tape intersects with existing values, and the interval_intersect flag should be false.
  • Subsequent forward passes at new points: postshould be set by user option,isintersectshould be true so that the tape intersects with existing values, and theintervalintersectflag should betrue` as predetermined interval bounds are valid but the prior values may correspond to different points of evaluation.
source
EAGO.cut_condition — Method
cut_condition(t::ExtensionType, m::GlobalOptimizer) -> Bool
+

Returns true if a cut should be added and computes a new reference point to add the cut at. By default, checks that cut_max_iterations are not exceeded and that the improvement in the objective value associated with the previous cut is greater than both an absolute tolerance cut_ϵ_abs and a relative tolerance cut_ϵ_rel. Returns false otherwise.

source
EAGO.default_upper_heuristic — Method
default_upper_heuristic(m::GlobalOptimizer) -> Bool
+

Default check to see if the upper bounding problem should be run. By default, The upper bounding problem is run on every node up to depth upper_bounding_depth and is triggered with a probability of 0.5^(depth - upper_bounding_depth) afterwards for continuous problems. For integral problems, the upper_bounding_depth approach is used as well as running on every node up to depth upper_bounding_depth + cont_depth with another trigger of probability 0.5^(depth - upper_bounding_depth - cont_depth).

source
EAGO.diam — Method

Return the diameter of a variable (upper bound - lower bound).

source
EAGO.eliminate_fixed_variables! — Function
eliminate_fixed_variables!(::T, ::Vector{VariableInfo})

Eliminate fixed variables by rearrangment or restructuring of the AbstractEAGOConstraint.

Options for T (all are subtypes of AbstractEAGOConstraint):

  • AffineFunctionEq
  • AffineFunctionIneq
  • BufferedQuadraticIneq
  • BufferedNonlinearFunction{N,T} where {N, T<:RelaxTag}
  • NonlinearExpression{V,N,T} where {V, N, T<:RelaxTag}
source
EAGO.f_init! — Method

Initializes information in cache c for each node in g that may be used in a forward-pass of attribute t.

source
EAGO.fathom! — Method
fathom!(t::ExtensionType, m::GlobalOptimizer)
+

Remove nodes from the stack. By default, delete nodes from the stack if their lower bounds are greater than the current global upper bound.

source
EAGO.fbbt! — Function
fbbt!(m::GlobalOptimizer, f::T)

Performs feasibility-based bound tightening on a back-end constraint and returns true if it is feasible or false if it is infeasible.

Options for T (all are subtypes of AbstractEAGOConstraint):

  • AffineFunctionIneq
  • AffineFunctionEq
source
EAGO.fprop! — Method

Populates information associated with attribute t for a constant v at index k in cache c associated with graph g using information at index k.

source
EAGO.fprop! — Method

Populates information associated with attribute t for a expression v at index k in cache c associated with graph g using information taken from the children of k.

source
EAGO.fprop! — Method

Populates information associated with attribute t for a parameter v at index k in cache c associated with graph g using information at index k.

source
EAGO.fprop! — Method

Populates information associated with attribute t for a subexpression v at index k in cache c associated with graph g using information taken from the children of k.

source
EAGO.fprop! — Method

Populates information associated with attribute t for a variable v at index k in cache c associated with graph g using information at index k.

source
EAGO.get_sip_optimizer — Method
get_sip_optimizer

Specifices the optimizer to be used in extension t::EAGO.ExtensionType with algorithm alg::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command get_sip_optimizer(t::ExtensionType, alg::AbstractSIPAlgo, s::AbstractSubproblemType).

source
EAGO.global_solve! — Method
global_solve!(m::GlobalOptimizer)
+

Solves the branch-and-bound problem with the input EAGO.GlobalOptimizer object.

Pseudocode description of the algorithm, as implemented here:

-I) Prepare optimizers and stack for branch-and-bound

-II) While no reason to terminate the algorithm has occurred:

–-II.A) Fathom nodes from the stack

–-II.B) Select the new "current node" from the stack

–-II.C) Perform preprocessing on current node

–-II.D) If preprocessing result is feasible:

––-II.D.1) Solve lower problem for current node

––-II.D.2) If lower problem result is feasible and lower/upper bounds have not converged:

–––-II.D.2.a) Solve upper problem for current node

–––-II.D.2.b) Update the global upper bound if necessary

–––-II.D.2.c) Perform postprocessing

–––-II.D.2.d) If postprocessing result is feasible:

––––-II.D.2.d.α) Branch and add the nodes back to the stack

–-II.E) Update the global lower bound if necessary

–-II.F) Update log information

-III) Set termination and result statuses

-IV) Print solution

source
EAGO.initial_parse! — Method
initial_parse!(m::Optimizer{R, S, T})
+

Translate the input problem to the working problem. Any checks or optional manipulation are left to the presolve stage.

source
EAGO.initialize! — Method
initialize!(_::AbstractCache, _::AbstractDirectedGraph)
+

Function used to initialize the storage cache d::AbstractCache for a given type of directed acyclic graph g::AbstractDirectedGraph.

source
EAGO.initialize_stack! — Method
initialize_stack!(t::ExtensionType, m::GlobalOptimizer)
+

Prepare the stack for the branch-and-bound routine. By default, create an initial node with the variable bounds as box constraints and add it to the stack.

source
EAGO.interval_bound — Function
interval_bound(::GlobalOptimizer, ::T)

Compute a tuple representing the lower and upper interval bounds for an AbstractEAGOConstraint representing an equality constraint.

Options for T (all are subtypes of AbstractEAGOConstraint):

  • AffineFunctionEq
  • AffineFunctionIneq
  • BufferedQuadraticEq
  • BufferedQuadraticIneq
  • BufferedNonlinearFunction{V,N,T} where {V,N,T}
source
EAGO.interval_objective_bound! — Function
source
EAGO.is_feasible — Method
is_feasible(::GlobalOptimizer, ::T)

Check if a given bound is feasible.

Options for T (all are subtypes of AbstractEAGOConstraint):

  • AffineFunctionIneq
  • AffineFunctionEq
  • BufferedQuadraticIneq
  • BufferedQuadraticEq
  • BufferedNonlinearFunction{V,N,T}
source
EAGO.is_integer_feasible_local — Method
is_integer_feasible_local(m::GlobalOptimizer, d) -> Bool
+

Checks that the solution of a local solve is integer feasible to within the tolerances specified by integer_abs_tol and integer_rel_tol.

source
EAGO.is_integer_feasible_relaxed — Method
is_integer_feasible_relaxed(m::GlobalOptimizer) -> Bool
+

Check that the solution of the lower (relaxed problem) is integer feasible to within tolerances specified by the parameters: integer_abs_tol (absolute tolerance) and integer_rel_tol (relative tolerance).

source
EAGO.is_integer_subproblem — Method
is_integer_subproblem(m)
+

Returns true that the subproblem at the current node n has participating integer variables that have not been fixed to constant valued as the branch-and-bound algorithm progresses. Returns false otherwise.

source
EAGO.is_safe_cut! — Method
is_safe_cut!(
     m::GlobalOptimizer,
     f::MathOptInterface.ScalarAffineFunction{Float64}
 ) -> Bool
-

Applies the safe cut checks detailed in Khajavirad, 2018 [Khajavirad, Aida, and Nikolaos V. Sahinidis. "A hybrid LP/NLP paradigm for global optimization relaxations." Mathematical Programming Computation 10.3 (2018): 383-421] to ensure that only numerically safe affine relaxations are added. Checks that:

  1. |b| <= safe b,
  2. safe_l <= abs(ai) <= safe u, and
  3. safe_l <= abs(ai/aj) <= safe_u.
source
EAGO.label_branch_variables! — Method
label_branch_variables!(m::GlobalOptimizer)
-

Detect any variables participating in nonconvex terms and populate the _branch_variables storage array.

source
EAGO.label_fixed_variables! — Method
label_fixed_variables!(m::GlobalOptimizer) -> Vector{Bool}
-

Detect any variables set to a fixed value by equality or inequality constraints and populate the _fixed_variable storage array.

source
EAGO.load_fbbt_buffer! — Method
load_fbbt_buffer!(m::GlobalOptimizer)
-
source
EAGO.load_relaxed_problem! — Method
load_relaxed_problem!(
+

Applies the safe cut checks detailed in Khajavirad, 2018 [Khajavirad, Aida, and Nikolaos V. Sahinidis. "A hybrid LP/NLP paradigm for global optimization relaxations." Mathematical Programming Computation 10.3 (2018): 383-421] to ensure that only numerically safe affine relaxations are added. Checks that:

  1. |b| <= safe b,
  2. safe_l <= abs(ai) <= safe u, and
  3. safe_l <= abs(ai/aj) <= safe_u.
source
EAGO.label_branch_variables! — Method
label_branch_variables!(m::GlobalOptimizer)
+

Detect any variables participating in nonconvex terms and populate the _branch_variables storage array.

source
EAGO.label_fixed_variables! — Method
label_fixed_variables!(m::GlobalOptimizer) -> Vector{Bool}
+

Detect any variables set to a fixed value by equality or inequality constraints and populate the _fixed_variable storage array.

source
EAGO.load_fbbt_buffer! — Method
load_fbbt_buffer!(m::GlobalOptimizer)
+
source
EAGO.load_relaxed_problem! — Method
load_relaxed_problem!(
     m::GlobalOptimizer{R, S, Q<:ExtensionType}
 )
-

Load variables, linear constraints, and empty storage space for the first NLP and quadratic cut into the relaxed optimizer.

source
EAGO.local_problem_status — Method
local_problem_status(t, r)
-

Takes an MOI.TerminationStatusCode and a MOI.ResultStatusCode and returns true if this corresponds to a solution that is proven to be feasible. Returns false otherwise.

source
EAGO.log_iteration! — Method
log_iteration!(m::GlobalOptimizer)
-

If log_on is true, the global_lower_bound, global_upper_bound, run_time, and node_count are stored every log_interval. If log_subproblem_info then the lower bound, feasibility and run times of the subproblems are logged every log_interval.

source
EAGO.lower_interval_bound — Function
lower_interval_bound(::GlobalOptimizer, ::T)

Compute the lower interval bound for an AbstractEAGOConstraint representing an inequality constraint.

Options for T (all are subtypes of AbstractEAGOConstraint):

  • AffineFunctionIneq
  • BufferedQuadraticIneq
  • BufferedSOC
  • BufferedNonlinearFunction{V,N,T} where {V,N,T}
source
EAGO.lower_problem! — Method
lower_problem!(
+

Load variables, linear constraints, and empty storage space for the first NLP and quadratic cut into the relaxed optimizer.

source
EAGO.local_problem_status — Method
local_problem_status(t, r)
+

Takes an MOI.TerminationStatusCode and a MOI.ResultStatusCode and returns true if this corresponds to a solution that is proven to be feasible. Returns false otherwise.

source
EAGO.log_iteration! — Method
log_iteration!(m::GlobalOptimizer)
+

If log_on is true, the global_lower_bound, global_upper_bound, run_time, and node_count are stored every log_interval. If log_subproblem_info then the lower bound, feasibility and run times of the subproblems are logged every log_interval.

source
EAGO.lower_interval_bound — Function
lower_interval_bound(::GlobalOptimizer, ::T)

Compute the lower interval bound for an AbstractEAGOConstraint representing an inequality constraint.

Options for T (all are subtypes of AbstractEAGOConstraint):

  • AffineFunctionIneq
  • BufferedQuadraticIneq
  • BufferedSOC
  • BufferedNonlinearFunction{V,N,T} where {V,N,T}
source
EAGO.lower_problem! — Method
lower_problem!(
     t::ExtensionType,
     m::GlobalOptimizer{R, S, Q<:ExtensionType}
 )
-

Constructs a relaxation of the MINLP on node y and solves it using the default EAGO relaxation scheme. By default, EAGO applies Kelley's algorithm (from Kelley Jr., J.E.: The cutting-plane method for solving convex programs. J. Soc. Ind. Appl. Math. 8(4), 703 to 712 (1960)) while cut_condition(m) returns true then activates the integrality constraints of the relaxed problems and solves the resulting MILP relaxation. results are stored to the _lower_solution, _lower_termination_status, _lower_primal_status, _lower_dual_status, _lower_objective_value, and _lower_feasibility. Further, lower and upper variable duals are stored _lower_lvd and _lower_uvd, respectively, for use in duality based bound tightening. If relaxation-based bounds are weaker or cutting-planes are numerically poorly ill-posed, then interval bounds are used instead. If the problem is dual feasible but the primal status is ambiguous the dual objective value is used for the lower bound to avoid numerical issues.

source
EAGO.mc_type — Method
mc_type(::RelaxCache{V, N, T} where {V, N, T<:RelaxTag}
+

Constructs a relaxation of the MINLP on node y and solves it using the default EAGO relaxation scheme. By default, EAGO applies Kelley's algorithm (from Kelley Jr., J.E.: The cutting-plane method for solving convex programs. J. Soc. Ind. Appl. Math. 8(4), 703 to 712 (1960)) while cut_condition(m) returns true then activates the integrality constraints of the relaxed problems and solves the resulting MILP relaxation. results are stored to the _lower_solution, _lower_termination_status, _lower_primal_status, _lower_dual_status, _lower_objective_value, and _lower_feasibility. Further, lower and upper variable duals are stored _lower_lvd and _lower_uvd, respectively, for use in duality based bound tightening. If relaxation-based bounds are weaker or cutting-planes are numerically poorly ill-posed, then interval bounds are used instead. If the problem is dual feasible but the primal status is ambiguous the dual objective value is used for the lower bound to avoid numerical issues.

source
EAGO.mc_type — Method
mc_type(::RelaxCache{V, N, T} where {V, N, T<:RelaxTag}
 mc_type(::NonlinearExpression{V, N, T} where {V, N, T<:RelaxTag}
-mc_type(::BufferedNonlinearFunction{V, N, T} where {V, N, T<:RelaxTag}

Returns a McCormick structure of type MC{N, T<:RelaxTag}.

source
EAGO.mid — Method

Return the midpoint of a variable (0.5*(upper bound + lower bound)).

source
EAGO.node_selection! — Method
node_selection!(t::ExtensionType, m::GlobalOptimizer)
-

Select the next node in the stack to evaluate. By default, perform best-first node selection (select the node with the lowest lower bound in the stack).

source
EAGO.obbt! — Method
obbt!(m::GlobalOptimizer{R, S, Q<:ExtensionType}) -> Bool
-

Performs OBBT with filtering and greedy ordering as detailed in: Gleixner, A.M., Berthold, T., Müller, B. et al. J Glob Optim (2017) 67: 731. https://doi.org/10.1007/s10898-016-0450-4

source
EAGO.objective_cut! — Method

objective_cut!

Add linear objective cut constraint to the m._subsolvers.relaxed_optimizer.

source
EAGO.optimize_hook! — Method
optimize_hook!(t::ExtensionType, m::Optimizer)

Provide a hook for extensions to EAGO.

The user-defined extension of optimize_hook! is used in EAGO's overloading of MOI.optimize! (see EAGO.jl/src/eago_optimizer/optimize/optimize.jl). Without the optimize_hook! specified, EAGO will run initial_parse!, parse_classify_problem!, and then optimize! using the parsed problem type. The user-specified optimize_hook! should thus take the new extension and Optimizer as inputs and will execute when the user writes optimize!(model).

Example

Here, optimize_hook! is used to bypass EAGO's problem parsing and treat every problem using its branch-and-bound routine. This is done in this example by telling EAGO to treat the problem as a mixed integer nonconvex problem, which normally dispatches to branch-and-bound.

struct MyNewExtension <: EAGO.ExtensionType end
+mc_type(::BufferedNonlinearFunction{V, N, T} where {V, N, T<:RelaxTag}

Returns a McCormick structure of type MC{N, T<:RelaxTag}.

source
EAGO.mid — Method

Return the midpoint of a variable (0.5*(upper bound + lower bound)).

source
EAGO.node_selection! — Method
node_selection!(t::ExtensionType, m::GlobalOptimizer)
+

Select the next node in the stack to evaluate. By default, perform best-first node selection (select the node with the lowest lower bound in the stack).

source
EAGO.obbt! — Method
obbt!(m::GlobalOptimizer{R, S, Q<:ExtensionType}) -> Bool
+

Performs OBBT with filtering and greedy ordering as detailed in: Gleixner, A.M., Berthold, T., Müller, B. et al. J Glob Optim (2017) 67: 731. https://doi.org/10.1007/s10898-016-0450-4

source
EAGO.objective_cut! — Method

objective_cut!

Add linear objective cut constraint to the m._subsolvers.relaxed_optimizer.

source
EAGO.optimize_hook! — Method
optimize_hook!(t::ExtensionType, m::Optimizer)

Provide a hook for extensions to EAGO.

The user-defined extension of optimize_hook! is used in EAGO's overloading of MOI.optimize! (see EAGO.jl/src/eago_optimizer/optimize/optimize.jl). Without the optimize_hook! specified, EAGO will run initial_parse!, parse_classify_problem!, and then optimize! using the parsed problem type. The user-specified optimize_hook! should thus take the new extension and Optimizer as inputs and will execute when the user writes optimize!(model).

Example

Here, optimize_hook! is used to bypass EAGO's problem parsing and treat every problem using its branch-and-bound routine. This is done in this example by telling EAGO to treat the problem as a mixed integer nonconvex problem, which normally dispatches to branch-and-bound.

struct MyNewExtension <: EAGO.ExtensionType end
 import EAGO: optimize_hook!
 function EAGO.optimize_hook!(t::MyNewExtension, m::Optimizer)
     initial_parse!(m)
     optimize!(EAGO.MINCVX(), m)
-end

The same functionality could be accomplished by setting the EAGOParameter field force_global_solve to be true.

source
EAGO.parse_classify_problem! — Method
parse_classify_problem!(m::GlobalOptimizer)

Interprets the type/number of constraints and the type of objective function to infer a problem type. Current possible types include:

  • LP: Linear program; sent to optimize_lp.jl
  • 'MILP: Mixed integer linear program; sent tooptimize_lp.jl`
  • SOCP: Second-order cone program; sent to optimize_conic.jl
  • MINCVX: Mixed-integer nonconvex; sent to optimize_nonconvex.jl

If the force_global_solve parameter is set to true, parse_classify_problem! will set the problem type to MINCVX to pass the problem to optimize_nonconvex.jl.

source
EAGO.parse_global! — Method

Basic parsing for global solutions (no extensive manipulation). By default, does nothing.

source
EAGO.postprocess! — Method
postprocess!(t::ExtensionType, m::GlobalOptimizer)
-

Default postprocess perfoms duality-based bound tightening (Tawarmalani, M., Sahinidis, N.V.: Global optimization of mixed-integer nonlinear programs: a theoretical and computational study. Math. Progr. 99, 563–591 (2004).) up to an iteration limit set by dbbt_depth.

source
EAGO.preprocess! — Method
preprocess!(
+end

The same functionality could be accomplished by setting the EAGOParameter field force_global_solve to be true.

source
EAGO.parse_classify_problem! — Method
parse_classify_problem!(m::GlobalOptimizer)

Interprets the type/number of constraints and the type of objective function to infer a problem type. Current possible types include:

  • LP: Linear program; sent to optimize_lp.jl
  • 'MILP: Mixed integer linear program; sent tooptimize_lp.jl`
  • SOCP: Second-order cone program; sent to optimize_conic.jl
  • MINCVX: Mixed-integer nonconvex; sent to optimize_nonconvex.jl

If the force_global_solve parameter is set to true, parse_classify_problem! will set the problem type to MINCVX to pass the problem to optimize_nonconvex.jl.

source
EAGO.parse_global! — Method

Basic parsing for global solutions (no extensive manipulation). By default, does nothing.

source
EAGO.postprocess! — Method
postprocess!(t::ExtensionType, m::GlobalOptimizer)
+

Default postprocess perfoms duality-based bound tightening (Tawarmalani, M., Sahinidis, N.V.: Global optimization of mixed-integer nonlinear programs: a theoretical and computational study. Math. Progr. 99, 563–591 (2004).) up to an iteration limit set by dbbt_depth.

source
EAGO.preprocess! — Method
preprocess!(
     t::ExtensionType,
     m::GlobalOptimizer{R, S, Q<:ExtensionType}
 )
-

Runs contractor methods prior to solving lower bounding problem. By default linear and quadratic contractor methods followed by interval constraint propagation then optimization-based bound tightening for a specified number of iterations while the subproblem at current node n has not been proven infeasible.

source
EAGO.presolve_global! — Method
presolve_global!(t::ExtensionType, m::GlobalOptimizer)
-

Perform any necessary work prior to running branch-and-bound.

  • Set subsolver configs using values in EAGOParameters;
  • Load variables, linear constraints, and empty storage space into the relaxed optimizer;
  • Prepare the stack for the start of branch-and-bound;
  • Fill fields of the GlobalOptimizer with zeros of the proper dimensions;
  • Pass necessary flags from the GlobalOptimizer to the working problem.
source
EAGO.print_iteration! — Method

print_iteration!

Print status information based on iteration count. The header print frequency is based on the header_iterations setting, and the data print frequency is based on the output_iterations setting.

source
EAGO.print_node! — Method

print_node!

Print information about the current node. Includes node ID, lower bound, upper bound, and interval box.

source
EAGO.print_preamble! — Method

print_preamble!

Print noteworthy information prior to running branch-and-bound. Currently prints a note about flipping max(f) to -min(-f) internally, if a maximization problem is inputted and verbosity>=3.

source
EAGO.print_results! — Method
print_results!(m::GlobalOptimizer, lower_flag::Bool)
-

Print the results of a single (lower or upper) bounding problem. lower_flag=true prints information for the lower problem, lower_flag=false prints information for the upper problem.

source
EAGO.print_solution! — Method

print_solution!

Print solution information for the B&B problem. Display node with the best solution, solution value, solution, and time spent solving subproblems. This print occurs following termination of the B&B algorithm.

source
EAGO.r_init! — Method

Initializes information in cache c for each node in g that may be used in a reverse-pass of attribute t.

source
EAGO.reform_epigraph_min! — Method
reform_epigraph_min!(m::GlobalOptimizer)
-

Perform an epigraph reformulation assuming the working_problem is a minimization problem.

source
EAGO.register_eago_operators! — Method

registereagooperators!

Registers all nonstandard nonlinear terms available in EAGO in a JuMP. Uses of these is generally preferable in EAGO as the relaxations EAGO will generate will usually be tighter (speeding up convergence time). Note that this will work can be used by other nonlinear solvers (Ipopt for instance).

source
EAGO.rel_diam — Method
rel_diam(m::GlobalOptimizer, i::Int64) -> Float64
-

Return the relative diameter of a variable. In the case of diam(X)=Inf, rel_diam returns 0.0 to prevent "branching" on this variable endlessly.

source
EAGO.relax! — Method
relax!(
+

Runs contractor methods prior to solving lower bounding problem. By default linear and quadratic contractor methods followed by interval constraint propagation then optimization-based bound tightening for a specified number of iterations while the subproblem at current node n has not been proven infeasible.

source
EAGO.presolve_global! — Method
presolve_global!(t::ExtensionType, m::GlobalOptimizer)
+

Perform any necessary work prior to running branch-and-bound.

  • Set subsolver configs using values in EAGOParameters;
  • Load variables, linear constraints, and empty storage space into the relaxed optimizer;
  • Prepare the stack for the start of branch-and-bound;
  • Fill fields of the GlobalOptimizer with zeros of the proper dimensions;
  • Pass necessary flags from the GlobalOptimizer to the working problem.
source
EAGO.print_iteration! — Method

print_iteration!

Print status information based on iteration count. The header print frequency is based on the header_iterations setting, and the data print frequency is based on the output_iterations setting.

source
EAGO.print_node! — Method

print_node!

Print information about the current node. Includes node ID, lower bound, upper bound, and interval box.

source
EAGO.print_preamble! — Method

print_preamble!

Print noteworthy information prior to running branch-and-bound. Currently prints a note about flipping max(f) to -min(-f) internally, if a maximization problem is inputted and verbosity>=3.

source
EAGO.print_results! — Method
print_results!(m::GlobalOptimizer, lower_flag::Bool)
+

Print the results of a single (lower or upper) bounding problem. lower_flag=true prints information for the lower problem, lower_flag=false prints information for the upper problem.

source
EAGO.print_solution! — Method

print_solution!

Print solution information for the B&B problem. Display node with the best solution, solution value, solution, and time spent solving subproblems. This print occurs following termination of the B&B algorithm.

source
EAGO.r_init! — Method

Initializes information in cache c for each node in g that may be used in a reverse-pass of attribute t.

source
EAGO.reform_epigraph_min! — Method
reform_epigraph_min!(m::GlobalOptimizer)
+

Perform an epigraph reformulation assuming the working_problem is a minimization problem.

source
EAGO.register_eago_operators! — Method

registereagooperators!

Registers all nonstandard nonlinear terms available in EAGO in a JuMP. Uses of these is generally preferable in EAGO as the relaxations EAGO will generate will usually be tighter (speeding up convergence time). Note that this will work can be used by other nonlinear solvers (Ipopt for instance).

source
EAGO.rel_diam — Method
rel_diam(m::GlobalOptimizer, i::Int64) -> Float64
+

Return the relative diameter of a variable. In the case of diam(X)=Inf, rel_diam returns 0.0 to prevent "branching" on this variable endlessly.

source
EAGO.relax! — Method
relax!(
     m::GlobalOptimizer,
     f::EAGO.BufferedQuadraticEq,
     i::Int64,
     check_safe::Bool
 ) -> Bool
-
source
EAGO.relax! — Method
relax!(
+
source
EAGO.relax! — Method
relax!(
     m::GlobalOptimizer,
     f::EAGO.BufferedQuadraticIneq,
     k::Int64,
     check_safe::Bool
 ) -> Bool
-
source
EAGO.relax! — Method
relax!(
+
source
EAGO.relax! — Method
relax!(
     m::GlobalOptimizer{R, S, Q<:ExtensionType},
     f::EAGO.BufferedNonlinearFunction{V, N, T<:RelaxTag},
     k::Int64,
     check_safe::Bool
 ) -> Tuple{Bool, Bool}
-
source
EAGO.relax! — Function

relax!

Relax the constraint by adding an affine constraint to the model.

source
EAGO.relax_all_constraints! — Method
relax_all_constraints!(
+
source
EAGO.relax! — Function

relax!

Relax the constraint by adding an affine constraint to the model.

source
EAGO.relax_all_constraints! — Method
relax_all_constraints!(
     t::ExtensionType,
     m::GlobalOptimizer,
     k::Int64
 ) -> Tuple{Bool, Bool}
-

A routine that adds relaxations for all nonlinear constraints and quadratic constraints corresponding to the current node to the relaxed problem. This adds an objective cut (if specified by objective_cut_on) and then sets the _new_eval_constraint flag to false indicating that an initial evaluation of the constraints has occurred. If the objective_cut_on flag is true then the _new_eval_objective flag is also set to false indicating that the objective expression was evaluated.

source
EAGO.relaxed_problem_status — Method
relaxed_problem_status(t, p, d)
-

Take an MOI.TerminationStatusCode and two MOI.ResultStatusCodes (one each for the primal and dual status) and return a RelaxResultStatus. Returns RRS_OPTIMAL if the codes prove that the subproblem solution was solved to global optimality. Returns RRS_INFEASIBLE if the codes prove that the subproblem solution is infeasible. Returns RRS_DUAL_FEASIBLE if subproblem solution is not optimal and not proven infeasible, but the dual status is MOI.FEASIBLE_POINT. Returns RRS_INVALID otherwise.

source
EAGO.repeat_check — Method
repeat_check(t::ExtensionType, m::GlobalOptimizer) -> Bool
-

Check to see if current node should be reprocessed. Without any custom extension, return false by default.

source
EAGO.rprop! — Method

Populates information associated with attribute t for a constant v at index k in cache c associated with graph g using information at index k taken from the parents of k.

source
EAGO.rprop! — Method

Populates information associated with attribute t for a expressions v at index k in cache c associated with graph g using information at index k taken from the parents of k.

source
EAGO.rprop! — Method

Populates information associated with attribute t for a parameters v at index k in cache c associated with graph g using information at index k taken from the parents of k.

source
EAGO.rprop! — Method

Populates information associated with attribute t for a subexpressions v at index k in cache c associated with graph g using information at index k taken from the parents of k.

source
EAGO.rprop! — Method

Populates information associated with attribute t for a variable v at index k in cache c associated with graph g using information at index k taken from the parents of k.

source
EAGO.rprop! — Method

rprop!

Updates storage tapes with reverse evalution of node representing n = *(x,y,z...) which updates x, y, z and so on.

source
EAGO.rprop! — Method

rprop!

Updates storage tapes with reverse evalution of node representing n = +(x,y,z...) which updates x, y, z and so on.

source
EAGO.rprop_2! — Method

rprop_2!

Updates storage tapes with reverse evalution of node representing n = x * y which updates x and y.

source
EAGO.rprop_2! — Method

rprop_2!

Updates storage tapes with reverse evalution of node representing n = x + y which updates x and y.

source
EAGO.rprop_n! — Method

rprop_n!

Updates storage tapes with reverse evalution of node representing n = *(x,y,z...) which updates x, y, z and so on.

source
EAGO.rprop_n! — Method

rprop_n!

Updates storage tapes with reverse evalution of node representing n = +(x,y,z...) which updates x, y, z and so on.

source
EAGO.same_box — Method
same_box(x::NodeBB, y::NodeBB, r::Float64) -> Bool
-

Check that node x and y have equal domains within an absolute tolerance of r.

source
EAGO.select_branch_point — Method
select_branch_point(
+

A routine that adds relaxations for all nonlinear constraints and quadratic constraints corresponding to the current node to the relaxed problem. This adds an objective cut (if specified by objective_cut_on) and then sets the _new_eval_constraint flag to false indicating that an initial evaluation of the constraints has occurred. If the objective_cut_on flag is true then the _new_eval_objective flag is also set to false indicating that the objective expression was evaluated.

source
EAGO.relaxed_problem_status — Method
relaxed_problem_status(t, p, d)
+

Take an MOI.TerminationStatusCode and two MOI.ResultStatusCodes (one each for the primal and dual status) and return a RelaxResultStatus. Returns RRS_OPTIMAL if the codes prove that the subproblem solution was solved to global optimality. Returns RRS_INFEASIBLE if the codes prove that the subproblem solution is infeasible. Returns RRS_DUAL_FEASIBLE if subproblem solution is not optimal and not proven infeasible, but the dual status is MOI.FEASIBLE_POINT. Returns RRS_INVALID otherwise.

source
EAGO.repeat_check — Method
repeat_check(t::ExtensionType, m::GlobalOptimizer) -> Bool
+

Check to see if current node should be reprocessed. Without any custom extension, return false by default.

source
EAGO.rprop! — Method

Populates information associated with attribute t for a constant v at index k in cache c associated with graph g using information at index k taken from the parents of k.

source
EAGO.rprop! — Method

Populates information associated with attribute t for a expressions v at index k in cache c associated with graph g using information at index k taken from the parents of k.

source
EAGO.rprop! — Method

Populates information associated with attribute t for a parameters v at index k in cache c associated with graph g using information at index k taken from the parents of k.

source
EAGO.rprop! — Method

Populates information associated with attribute t for a subexpressions v at index k in cache c associated with graph g using information at index k taken from the parents of k.

source
EAGO.rprop! — Method

Populates information associated with attribute t for a variable v at index k in cache c associated with graph g using information at index k taken from the parents of k.

source
EAGO.rprop! — Method

rprop!

Updates storage tapes with reverse evalution of node representing n = *(x,y,z...) which updates x, y, z and so on.

source
EAGO.rprop! — Method

rprop!

Updates storage tapes with reverse evalution of node representing n = +(x,y,z...) which updates x, y, z and so on.

source
EAGO.rprop_2! — Method

rprop_2!

Updates storage tapes with reverse evalution of node representing n = x * y which updates x and y.

source
EAGO.rprop_2! — Method

rprop_2!

Updates storage tapes with reverse evalution of node representing n = x + y which updates x and y.

source
EAGO.rprop_n! — Method

rprop_n!

Updates storage tapes with reverse evalution of node representing n = *(x,y,z...) which updates x, y, z and so on.

source
EAGO.rprop_n! — Method

rprop_n!

Updates storage tapes with reverse evalution of node representing n = +(x,y,z...) which updates x, y, z and so on.

source
EAGO.same_box — Method
same_box(x::NodeBB, y::NodeBB, r::Float64) -> Bool
+

Check that node x and y have equal domains within an absolute tolerance of r.

source
EAGO.select_branch_point — Method
select_branch_point(
     t::ExtensionType,
     m::GlobalOptimizer,
     i
 ) -> Float64
-

Select a point xb within the domain of the ith branching variable. By default, this point is a convex combination of the solution to the relaxation and the midpoint of the node (branch_cvx_factor*xmid + (1-branch_cvx_factor)*xsol). If the solution lies within branch_offset of a bound, then the branch point is moved to a distance of branch_offset from that bound.

source
EAGO.select_branch_variable — Method
select_branch_variable(
+

Select a point xb within the domain of the ith branching variable. By default, this point is a convex combination of the solution to the relaxation and the midpoint of the node (branch_cvx_factor*xmid + (1-branch_cvx_factor)*xsol). If the solution lies within branch_offset of a bound, then the branch point is moved to a distance of branch_offset from that bound.

source
EAGO.select_branch_variable — Method
select_branch_variable(
     t::ExtensionType,
     m::GlobalOptimizer
 ) -> Any
-

Choose a variable to branch on. A maximum relative width branching rule is used by default.

source
EAGO.set_constraint_propagation_fbbt! — Method
set_constraint_propagation_fbbt!(
+

Choose a variable to branch on. A maximum relative width branching rule is used by default.

source
EAGO.set_constraint_propagation_fbbt! — Method
set_constraint_propagation_fbbt!(
     m::GlobalOptimizer{R, S, Q<:ExtensionType}
 ) -> Bool
-

Performs bound tightening based on forward/reverse interval and/or McCormick passes. This routine resets the current node with new interval bounds.

source
EAGO.set_default_config! — Method
set_default_config!

Configures subsolver tolerances based on tolerance parameters provided to EAGO (provided that a specialized subsolver configuration routine has been provided and m.user_solver_config = false).

source
EAGO.set_dual! — Method
set_dual!(m)
-

Retrieves the lower and upper duals for variable bounds from the relaxed_optimizer and sets the appropriate values in the _lower_lvd and _lower_uvd storage fields.

source
EAGO.set_first_relax_point! — Method
set_first_relax_point!(m::GlobalOptimizer)
-
source
EAGO.set_global_lower_bound! — Method
set_global_lower_bound!(m::GlobalOptimizer)
-

If the previous best-known global lower bound is lower than the lowest lower bound in the stack, set the global lower bound equal to the lowest lower bound in the stack.

source
EAGO.set_node! — Method

set_node!

Sets the current node in the Evaluator structure.

source
EAGO.set_reference_point! — Method
set_reference_point!(m::GlobalOptimizer)
-
source
EAGO.set_result_status! — Method
set_result_status!(m::GlobalOptimizer)
-

Convert EAGO's ending status code into an MOI.ResultStatusCode.

source
EAGO.set_termination_status! — Method
set_termination_status!(m::GlobalOptimizer)
-

Convert EAGO's ending status code into an MOI.TerminationStatusCode.

source
EAGO.single_storage! — Method
single_storage!(t::ExtensionType, m::GlobalOptimizer)
-

Store the current node to the stack, without branching, after updating lower/upper bounds.

source
EAGO.sip_bnd! — Method
sip_bnd!

Solves the bounding problem for the ith-SIP used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_bnd!(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, ..., i, tol).

source
EAGO.sip_llp! — Method
sip_llp!

Solves the lower level problem for the ith-SIP used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_llp!(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, ..., i, tol).

source
EAGO.sip_res! — Method
sip_res!

Solves the restriction problem for extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_res!(t::ExtensionType, a::AbstractSIPAlgo, ...).

source
EAGO.sip_solve — Method
sip_solve

Solve an SIP with decision variable bounds x_l to x_u, uncertain variable bounds p_l to p_u, an objective function of f, and gSIP seminfiniite constraint(s).

source
EAGO.solve_local_nlp! — Method

Constructs and solves the problem locally on node y updated the upper solution informaton in the optimizer.

source
EAGO.store_candidate_solution! — Method
store_candidate_solution!(m::GlobalOptimizer)
-

If the most recent upper problem returned a feasible result, and the upper objective value is less than the previous best-known global upper bound, set the most recent upper problem result to be the new global upper bound. Update the _feasible_solution_found, _solution_node, _global_upper_bound, and _continuous_solution fields of the GlobalOptimizer accordingly.

source
EAGO.stored_adjusted_upper_bound! — Method
stored_adjusted_upper_bound!(d, v)
-

Shifts the resulting local nlp objective value f* by (1.0 + relative_tolerance/100.0)*f* + absolute_tolerance/100.0. This assumes that the local solvers relative tolerance and absolute tolerance is significantly lower than the global tolerance (local problem is minimum).

source
EAGO.termination_check — Method
termination_check(m::GlobalOptimizer)
-termination_check(t::ExtensionType, m::GlobalOptimizer) -> Bool

Check for termination of the branch-and-bound algorithm.

If only the GlobalOptimizer is given as an argument, termination_check dispatches to the other form using the ExtensionType given in the SubSolvers. If there is no user-defined extension, then by default, this will check for satisfaction of absolute or relative tolerances, solution infeasibility, and other specified limits. Returns true if any conditions are met and branch-and-bound should end, and false otherwise.

source
EAGO.trivial_filtering! — Method
trivial_filtering!(
+

Performs bound tightening based on forward/reverse interval and/or McCormick passes. This routine resets the current node with new interval bounds.

source
EAGO.set_default_config! — Method
set_default_config!

Configures subsolver tolerances based on tolerance parameters provided to EAGO (provided that a specialized subsolver configuration routine has been provided and m.user_solver_config = false).

source
EAGO.set_dual! — Method
set_dual!(m)
+

Retrieves the lower and upper duals for variable bounds from the relaxed_optimizer and sets the appropriate values in the _lower_lvd and _lower_uvd storage fields.

source
EAGO.set_first_relax_point! — Method
set_first_relax_point!(m::GlobalOptimizer)
+
source
EAGO.set_global_lower_bound! — Method
set_global_lower_bound!(m::GlobalOptimizer)
+

If the previous best-known global lower bound is lower than the lowest lower bound in the stack, set the global lower bound equal to the lowest lower bound in the stack.

source
EAGO.set_node! — Method

set_node!

Sets the current node in the Evaluator structure.

source
EAGO.set_reference_point! — Method
set_reference_point!(m::GlobalOptimizer)
+
source
EAGO.set_result_status! — Method
set_result_status!(m::GlobalOptimizer)
+

Convert EAGO's ending status code into an MOI.ResultStatusCode.

source
EAGO.set_termination_status! — Method
set_termination_status!(m::GlobalOptimizer)
+

Convert EAGO's ending status code into an MOI.TerminationStatusCode.

source
EAGO.single_storage! — Method
single_storage!(t::ExtensionType, m::GlobalOptimizer)
+

Store the current node to the stack, without branching, after updating lower/upper bounds.

source
EAGO.sip_bnd! — Method
sip_bnd!

Solves the bounding problem for the ith-SIP used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_bnd!(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, ..., i, tol).

source
EAGO.sip_llp! — Method
sip_llp!

Solves the lower level problem for the ith-SIP used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_llp!(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, ..., i, tol).

source
EAGO.sip_res! — Method
sip_res!

Solves the restriction problem for extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_res!(t::ExtensionType, a::AbstractSIPAlgo, ...).

source
EAGO.sip_solve — Method
sip_solve

Solve an SIP with decision variable bounds x_l to x_u, uncertain variable bounds p_l to p_u, an objective function of f, and gSIP seminfiniite constraint(s).

source
EAGO.solve_local_nlp! — Method

Constructs and solves the problem locally on node y updated the upper solution informaton in the optimizer.

source
EAGO.store_candidate_solution! — Method
store_candidate_solution!(m::GlobalOptimizer)
+

If the most recent upper problem returned a feasible result, and the upper objective value is less than the previous best-known global upper bound, set the most recent upper problem result to be the new global upper bound. Update the _feasible_solution_found, _solution_node, _global_upper_bound, and _continuous_solution fields of the GlobalOptimizer accordingly.

source
EAGO.stored_adjusted_upper_bound! — Method
stored_adjusted_upper_bound!(d, v)
+

Shifts the resulting local nlp objective value f* by (1.0 + relative_tolerance/100.0)*f* + absolute_tolerance/100.0. This assumes that the local solvers relative tolerance and absolute tolerance is significantly lower than the global tolerance (local problem is minimum).

source
EAGO.termination_check — Method
termination_check(m::GlobalOptimizer)
+termination_check(t::ExtensionType, m::GlobalOptimizer) -> Bool

Check for termination of the branch-and-bound algorithm.

If only the GlobalOptimizer is given as an argument, termination_check dispatches to the other form using the ExtensionType given in the SubSolvers. If there is no user-defined extension, then by default, this will check for satisfaction of absolute or relative tolerances, solution infeasibility, and other specified limits. Returns true if any conditions are met and branch-and-bound should end, and false otherwise.

source
EAGO.trivial_filtering! — Method
trivial_filtering!(
     m::GlobalOptimizer{R, S, Q<:ExtensionType},
     n::NodeBB
 )
-

Excludes OBBT on variable indices that are tight for the solution of the relaxation.

source
EAGO.unbounded_check! — Method
unbounded_check!(m::GlobalOptimizer) -> Union{Nothing, Bool}
-

Check the optimization problem for unbounded branching variables, which would interfere with EAGO's branch-and-bound routine since there are no well-defined branching rules for cases where the interval bounds contain -Inf or Inf. If any branching variables are missing bounds, add the missing bound at +/- 1E10 and warn the user.

source
EAGO.unpack_fbbt_buffer! — Method
unpack_fbbt_buffer!(m::GlobalOptimizer)
-
source
EAGO.unpack_global_solution! — Method
unpack_global_solution!(
+

Excludes OBBT on variable indices that are tight for the solution of the relaxation.

source
EAGO.unbounded_check! — Method
unbounded_check!(m::GlobalOptimizer) -> Union{Nothing, Bool}
+

Check the optimization problem for unbounded branching variables, which would interfere with EAGO's branch-and-bound routine since there are no well-defined branching rules for cases where the interval bounds contain -Inf or Inf. If any branching variables are missing bounds, add the missing bound at +/- 1E10 and warn the user.

source
EAGO.unpack_fbbt_buffer! — Method
unpack_fbbt_buffer!(m::GlobalOptimizer)
+
source
EAGO.unpack_global_solution! — Method
unpack_global_solution!(
     m::Optimizer{R, S, Q<:ExtensionType}
 )
-

If global optimization was performed, much of the work happened within the _global_optimizer::GlobalOptimizer. The unpack_global_solution! function extracts results from the GlobalOptimizer and puts them in the correct fields of the Optimizer.

source
EAGO.unsafe_check_fill! — Method
unsafe_check_fill!(f, y::Array{T, 1}, x, n::Int64)
-

Performs map!(f, y, x) in an unsafe manner if y[i] is true, else no-op. Assumes n == length(x) == length(y). About 2x faster for small arrays (n < 1000).

[Unused]

source
EAGO.update_relaxed_problem_box! — Method
update_relaxed_problem_box!(m)
-

Update the relaxed constraint by setting the constraint set of v == x* , xL_i <= x_i, and x_i <= xU_i for each such constraint added to the relaxed optimizer. Resets integral valued constraints to either EqualTo or Interval constraints.

source
EAGO.upper_problem! — Method
upper_problem!(t::ExtensionType, m::GlobalOptimizer)
-

Default upper bounding problem which simply calls solve_local_nlp! to solve the NLP locally.

source
EAGO.variable_dbbt! — Method
variable_dbbt!(
+

If global optimization was performed, much of the work happened within the _global_optimizer::GlobalOptimizer. The unpack_global_solution! function extracts results from the GlobalOptimizer and puts them in the correct fields of the Optimizer.

source
EAGO.unsafe_check_fill! — Method
unsafe_check_fill!(f, y::Array{T, 1}, x, n::Int64)
+

Performs map!(f, y, x) in an unsafe manner if y[i] is true, else no-op. Assumes n == length(x) == length(y). About 2x faster for small arrays (n < 1000).

[Unused]

source
EAGO.update_relaxed_problem_box! — Method
update_relaxed_problem_box!(m)
+

Update the relaxed constraint by setting the constraint set of v == x* , xL_i <= x_i, and x_i <= xU_i for each such constraint added to the relaxed optimizer. Resets integral valued constraints to either EqualTo or Interval constraints.

source
EAGO.upper_problem! — Method
upper_problem!(t::ExtensionType, m::GlobalOptimizer)
+

Default upper bounding problem which simply calls solve_local_nlp! to solve the NLP locally.

source
EAGO.variable_dbbt! — Method
variable_dbbt!(
     n::NodeBB,
     mult_lo::Vector{Float64},
     mult_hi::Vector{Float64},
@@ -156,4 +156,4 @@
     UBD::Float64,
     nx::Int64
 )
-

Tighten the bounds of the _current_node using the current global upper bound and the duality information obtained from the relaxation.

source
EAGO.variable_load_parse! — Method
variable_load_parse!

Parse constraint information of a given constraint type to fill in related variable information.

source
+

Tighten the bounds of the _current_node using the current global upper bound and the duality information obtained from the relaxation.

source
EAGO.variable_load_parse! — Method
variable_load_parse!

Parse constraint information of a given constraint type to fill in related variable information.

source
diff --git a/dev/dev/api_types/index.html b/dev/dev/api_types/index.html index c74f86ba..c8c89dc3 100644 --- a/dev/dev/api_types/index.html +++ b/dev/dev/api_types/index.html @@ -1,2 +1,2 @@ -Types · EAGO.jl
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
+Types · EAGO.jl
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
diff --git a/dev/dev/contributing/index.html b/dev/dev/contributing/index.html index 6654f946..f3aced10 100644 --- a/dev/dev/contributing/index.html +++ b/dev/dev/contributing/index.html @@ -1,2 +1,2 @@ -Contributing · EAGO.jl
GitHub

How to Contribute to EAGO

We're always happy to welcome work with additional collaborators and contributors. One of the easy ways for newcomers to contribute is by adding additional McCormick relaxations.

If you have any requests for additional functionality, bug fixes, or comments, please feel free to open a new issue using the GitHub issue tracker or reach out to us.

Contact Us

Please direct technical issues and/or bugs to the active developers:

All other questions should be directed to Prof. Stuber.

+Contributing · EAGO.jl
GitHub

How to Contribute to EAGO

We're always happy to welcome work with additional collaborators and contributors. One of the easy ways for newcomers to contribute is by adding additional McCormick relaxations.

If you have any requests for additional functionality, bug fixes, or comments, please feel free to open a new issue using the GitHub issue tracker or reach out to us.

Contact Us

Please direct technical issues and/or bugs to the active developers:

All other questions should be directed to Prof. Stuber.

diff --git a/dev/dev/future/index.html b/dev/dev/future/index.html index 0d90270e..17954131 100644 --- a/dev/dev/future/index.html +++ b/dev/dev/future/index.html @@ -1,2 +1,2 @@ -Future Work · EAGO.jl
GitHub

Future Work

Current Activity

  • Update CI testing.
  • Specialized algorithms for relaxing ODE constrained problems and solving global and robust optimization problems.
  • Extensions for nonconvex dynamic global & robust optimization.
  • Provide support for mixed-integer problems.
  • Update EAGO to support nonsmooth problems (requires: a nonsmooth local nlp optimizer or lexicographic AD, support for relaxations is already included).
  • Evaluation and incorporation of implicit relaxation routines in basic solver.

Other Things on the Wishlist (But Not Actively Being Worked On)

  • Implement the interval constraint propagation scheme presented in Vu 2008. For improved convergences.
  • A parametric bisection routine will be updated that can divide the $(X, P)$ space into a series of boxes that all contain unique branches of the implicit function $p -> y(p)$.
  • Provide a better interface the nonconvex semi-infinite programs solvers (JuMPeR extension?).
  • Add additional McCormick relaxations.
  • Add handling for domain reduction of special expression forms.
+Future Work · EAGO.jl
GitHub

Future Work

Current Activity

  • Update CI testing.
  • Specialized algorithms for relaxing ODE constrained problems and solving global and robust optimization problems.
  • Extensions for nonconvex dynamic global & robust optimization.
  • Provide support for mixed-integer problems.
  • Update EAGO to support nonsmooth problems (requires: a nonsmooth local nlp optimizer or lexicographic AD, support for relaxations is already included).
  • Evaluation and incorporation of implicit relaxation routines in basic solver.

Other Things on the Wishlist (But Not Actively Being Worked On)

  • Implement the interval constraint propagation scheme presented in Vu 2008. For improved convergences.
  • A parametric bisection routine will be updated that can divide the $(X, P)$ space into a series of boxes that all contain unique branches of the implicit function $p -> y(p)$.
  • Provide a better interface the nonconvex semi-infinite programs solvers (JuMPeR extension?).
  • Add additional McCormick relaxations.
  • Add handling for domain reduction of special expression forms.
diff --git a/dev/examples/alpha_bb/index.html b/dev/examples/alpha_bb/index.html index 891b7499..26d6c7e8 100644 --- a/dev/examples/alpha_bb/index.html +++ b/dev/examples/alpha_bb/index.html @@ -106,4 +106,4 @@ JuMP.value(x[2])," f* = ",JuMP.objective_value(m)) TermStatus = JuMP.termination_status(m) PrimStatus = JuMP.primal_status(m) -println("Algorithm terminated with a status of $TermStatus and result code of $PrimStatus") +println("Algorithm terminated with a status of $TermStatus and result code of $PrimStatus") diff --git a/dev/examples/explicit_ann/index.html b/dev/examples/explicit_ann/index.html index 6ec547c6..a5c58b25 100644 --- a/dev/examples/explicit_ann/index.html +++ b/dev/examples/explicit_ann/index.html @@ -41,4 +41,4 @@ rescaled_xsol = ((xsol .+ 1.0)./2.0).*(xUBD - xLBD) .+ xLBD println("Rescaled optimal value and solution values:") println("The rescaled optimal value is: $(round(rescaled_fval, digits=4))") -println("The rescaled solution is $(round.(rescaled_xsol, digits=3)).")

References

  1. J. D. Smith, A. A. Neto, S. Cremaschi, and D. W. Crunkleton, CFD-based optimization of a flooded bed algae bioreactor, Industrial & Engineering Chemistry Research, 52 (2012), pp. 7181–7188.
  2. A. M. Schweidtmann and A. Mitsos. Global Deterministic Optimization with Artificial Neural Networks Embedded https://arxiv.org/pdf/1801.07114.pdf.
  3. Iain Dunning and Joey Huchette and Miles Lubin. JuMP: A Modeling Language for Mathematical Optimization, SIAM Review, 59 (2017), pp. 295-320.
+println("The rescaled solution is $(round.(rescaled_xsol, digits=3)).")

References

  1. J. D. Smith, A. A. Neto, S. Cremaschi, and D. W. Crunkleton, CFD-based optimization of a flooded bed algae bioreactor, Industrial & Engineering Chemistry Research, 52 (2012), pp. 7181–7188.
  2. A. M. Schweidtmann and A. Mitsos. Global Deterministic Optimization with Artificial Neural Networks Embedded https://arxiv.org/pdf/1801.07114.pdf.
  3. Iain Dunning and Joey Huchette and Miles Lubin. JuMP: A Modeling Language for Mathematical Optimization, SIAM Review, 59 (2017), pp. 295-320.
diff --git a/dev/examples/interval_bb/index.html b/dev/examples/interval_bb/index.html index 67d0685d..8aac8e51 100644 --- a/dev/examples/interval_bb/index.html +++ b/dev/examples/interval_bb/index.html @@ -63,4 +63,4 @@ status_prim = JuMP.primal_status(m) println("EAGO terminated with a status of $status_term and a result code of $status_prim") -println("The optimal value is: $(round(fval, digits=3)), the solution found is $(round.(xsol, digits=4)).")

Advice for More Advanced Constructions

The default lower_problem! and upper_problem! should be used as templates for error handling and retrieving information from MOI models.

Essentially all of EAGO's subroutines stored to a field in the Optimizer structure can be reset as user-defined functions.

References

  1. IntervalArithmetic.jl [Computer software] (2019). Retrieved from https://github.com/JuliaIntervals/IntervalArithmetic.jl
  2. Iain Dunning and Joey Huchette and Miles Lubin. JuMP: A Modeling Language for Mathematical Optimization, SIAM Review, SIAM 59 (2017), pp. 295-320.
+println("The optimal value is: $(round(fval, digits=3)), the solution found is $(round.(xsol, digits=4)).")

Advice for More Advanced Constructions

The default lower_problem! and upper_problem! should be used as templates for error handling and retrieving information from MOI models.

Essentially all of EAGO's subroutines stored to a field in the Optimizer structure can be reset as user-defined functions.

References

  1. IntervalArithmetic.jl [Computer software] (2019). Retrieved from https://github.com/JuliaIntervals/IntervalArithmetic.jl
  2. Iain Dunning and Joey Huchette and Miles Lubin. JuMP: A Modeling Language for Mathematical Optimization, SIAM Review, SIAM 59 (2017), pp. 295-320.
diff --git a/dev/examples/quasiconvex/index.html b/dev/examples/quasiconvex/index.html index 4fa44f59..407f0f18 100644 --- a/dev/examples/quasiconvex/index.html +++ b/dev/examples/quasiconvex/index.html @@ -75,4 +75,4 @@ JuMP.optimize!(m)

Retrieve Results

We then recover the solution values and the objective value using standard JuMP syntax.

solution = JuMP.value.(y[1:5])
 global_obj_value = JuMP.value.(y[6])
-print("Global solution at y*=$solution with a value of f*=$global_obj_value")

References

  1. C. Jansson, Quasiconvex relaxations based on interval arithmetic, Linear Algebra and its Applications, 324 (2001), pp. 27–53.
  2. S. Boyd and L. Vandenberghe, Convex optimization, Cambridge University Press, 2004.
  3. Iain Dunning and Joey Huchette and Miles Lubin. JuMP: A Modeling Language for Mathematical Optimization, SIAM Review, 59 (2017), pp. 295-320.
+print("Global solution at y*=$solution with a value of f*=$global_obj_value")

References

  1. C. Jansson, Quasiconvex relaxations based on interval arithmetic, Linear Algebra and its Applications, 324 (2001), pp. 27–53.
  2. S. Boyd and L. Vandenberghe, Convex optimization, Cambridge University Press, 2004.
  3. Iain Dunning and Joey Huchette and Miles Lubin. JuMP: A Modeling Language for Mathematical Optimization, SIAM Review, 59 (2017), pp. 295-320.
diff --git a/dev/index.html b/dev/index.html index 4d2a68a1..a18adf20 100644 --- a/dev/index.html +++ b/dev/index.html @@ -1,2 +1,2 @@ -Introduction · EAGO.jl
GitHub

logo

EAGO - Easy Advanced Global Optimization in Julia

A development environment for robust and global optimization in Julia.

Authors

  • Matthew Wilhelm, Department of Chemical and Biomolecular Engineering, University of Connecticut (UConn)
    • Current Position: Alexion Pharmaceuticals
  • Robert Gottlieb, Department of Chemical and Biomolecular Engineering, University of Connecticut (UConn)
  • Dimitri Alston, Department of Chemical and Biomolecular Engineering, University of Connecticut (UConn)
  • Matthew Stuber, Associate Professor, University of Connecticut (UConn)

If you would like to contribute, contact us.

Overview

EAGO is a global and robust optimization platform based on McCormick relaxations. It contains the first widely accessible global optimization routine based on generalized McCormick relaxations. With the exception of calls to local solvers and linear algebra routines, EAGO is written entirely in native Julia. The solver is flexibly arranged so the end user can easily customize low-level routines.

Installing EAGO

EAGO is a registered Julia package and it can be installed using the Julia package manager. From the Julia REPL, type ] to enter the Package manager (Pkg) mode and run the following command:

pkg> add EAGO

Currently, EAGO is compatible with version 1.12 of JuMP. This allows a replication of some of the internal features shared by EAGO and JuMP's automatic differentiation scheme, e.g., generation of Wengert Tapes, passing evaluators between JuMP and EAGO, etc.

pkg> add JuMP

EAGO v0.8.1 is the current tagged version and requires Julia 1.6+ for full functionality (however Julia 1.0+ versions support partial functionality). Use with version 1.8 is recommended as the majority of in-house testing has occurred using this version of Julia. The user is directed to the High-Performance Configuration for instructions on how to install a high performance version of EAGO (rather than the basic entirely open-source version). If any issues are encountered when loading EAGO (or when using it), please submit an issue using the GitHub issue tracker.

Examples

Several examples are provided within this documentation, but additional examples are provided in the form of Jupyter Notebooks at EAGO-notebooks which can be run using IJulia. To add IJulia, run the command:

pkg> add IJulia

Then launch the Jupyter Notebook using the following command from the Julia terminal:

julia> using IJulia; notebook()

And then simply navigate to the example directory and run the example of most interest.

+Introduction · EAGO.jl
GitHub

logo

EAGO - Easy Advanced Global Optimization in Julia

A development environment for robust and global optimization in Julia.

Authors

  • Matthew Wilhelm, Department of Chemical and Biomolecular Engineering, University of Connecticut (UConn)
    • Current Position: Alexion Pharmaceuticals
  • Robert Gottlieb, Department of Chemical and Biomolecular Engineering, University of Connecticut (UConn)
  • Dimitri Alston, Department of Chemical and Biomolecular Engineering, University of Connecticut (UConn)
  • Matthew Stuber, Associate Professor, University of Connecticut (UConn)

If you would like to contribute, contact us.

Overview

EAGO is a global and robust optimization platform based on McCormick relaxations. It contains the first widely accessible global optimization routine based on generalized McCormick relaxations. With the exception of calls to local solvers and linear algebra routines, EAGO is written entirely in native Julia. The solver is flexibly arranged so the end user can easily customize low-level routines.

Installing EAGO

EAGO is a registered Julia package and it can be installed using the Julia package manager. From the Julia REPL, type ] to enter the Package manager (Pkg) mode and run the following command:

pkg> add EAGO

Currently, EAGO is compatible with version 1.12 of JuMP. This allows a replication of some of the internal features shared by EAGO and JuMP's automatic differentiation scheme, e.g., generation of Wengert Tapes, passing evaluators between JuMP and EAGO, etc.

pkg> add JuMP

EAGO v0.8.1 is the current tagged version and requires Julia 1.6+ for full functionality (however Julia 1.0+ versions support partial functionality). Use with version 1.8 is recommended as the majority of in-house testing has occurred using this version of Julia. The user is directed to the High-Performance Configuration for instructions on how to install a high performance version of EAGO (rather than the basic entirely open-source version). If any issues are encountered when loading EAGO (or when using it), please submit an issue using the GitHub issue tracker.

Examples

Several examples are provided within this documentation, but additional examples are provided in the form of Jupyter Notebooks at EAGO-notebooks which can be run using IJulia. To add IJulia, run the command:

pkg> add IJulia

Then launch the Jupyter Notebook using the following command from the Julia terminal:

julia> using IJulia; notebook()

And then simply navigate to the example directory and run the example of most interest.

diff --git a/dev/jump/README/index.html b/dev/jump/README/index.html index e8f80abe..ce7479b8 100644 --- a/dev/jump/README/index.html +++ b/dev/jump/README/index.html @@ -1,54 +1,70 @@ -EAGO - Easy Advanced Global Optimization · EAGO.jl
GitHub

<img src="https://github.com/PSORLab/EAGO.jl/blob/master/docs/src/assets/logo.png" width="75%" height="75%">

EAGO - Easy Advanced Global Optimization

EAGO is an open-source development environment for robust and global optimization in Julia. See the full README for more information.

PSOR LabCurrent VersionBuild StatusDocumentation
Build Status codecov

EAGO is a deterministic global optimizer designed to address a wide variety of optimization problems, emphasizing nonlinear programs (NLPs), by propagating McCormick relaxations along the factorable structure of each expression in the NLP. Most operators supported by modern automatic differentiation (AD) packages are supported by EAGO and a number utilities for sanitizing native Julia code and generating relaxations on a wide variety of user-defined functions have been included. Currently, EAGO supports problems that have a priori variable bounds defined and have differentiable constraints. That is, problems should be specified in the generic form below:

$

\begin{align} f^{\} = & \min{\mathbf y \in Y \subset \mathbb R^{n{y}}} f(\mathbf y) \ -{\rm s.t.} \;\; & \mathbf h(\mathbf y) = \mathbf 0 \ -& \mathbf g(\mathbf y) \leq \mathbf 0 \ -& Y = [\mathbf y^{\mathbf L}, \mathbf y^{\mathbf U}] \in \mathbb{IR}^{n} \ -& \qquad \mathbf y^{\mathbf L}, \mathbf y^{\mathbf U} \in \mathbb R^{n} \end{align*} $

For each nonlinear term, EAGO makes use of factorable representations to construct bounds and relaxations. In the case of $f(x) = x (x - 5) \sin(x)$, a list is generated and rules for constructing McCormick relaxations are used to formulate relaxations in the original decision space, $X$ [1]:

  • \[v_{1} = x\]

  • \[v_{2} = v_{1} - 5\]

  • \[v_{3} = \sin(v_{1})\]

  • \[v_{4} = v_{1} v_{2}\]

  • \[v_{5} = v_{4} v_{3}\]

  • \[f(x) = v_{5}\]

<p align="center"> <img src="https://github.com/PSORLab/EAGO.jl/blob/master/docs/src/mccormick/Figure_1.png" width="60%" height="60%">

Either these original relaxations, differentiable McCormick relaxations [2], or affine relaxations thereof can be used to construct relaxations of optimization problems useful in branch and bound routines for global optimization. Utilities are included to combine these with algorithms for relaxing implicit functions [3] and forward-reverse propagation of McCormick arithmetic [4].

License

EAGO is licensed under the MIT License.

Installation

EAGO is a registered Julia package and it can be installed using the Julia package manager:

import Pkg
-Pkg.add("EAGO")

Use with JuMP

EAGO makes use of JuMP to improve the user's experience in setting up optimization models. Consider the "process" problem instance from [5]:

$

\begin{align} & \max{\mathbf x \in X} 0.063 x{4} x{7} - 5.04 x{1} - 0.035 x{2} - 10 x{3} - 3.36 x{2} \ -{\rm s.t.} \;\; & x{1} (1.12 + 0.13167 x{8} - 0.00667 x{8}^{2}) + x{4} = 0 \ -& -0.001 x{4} x{9} x{6} / (98 - x{6}) + x{3} = 0 \ -& -(1.098 x{8} - 0.038 x{8}^{2}) - 0.325 x{6} + x{7} = 0 \ -& -(x{2} + x{5}) / x{1} + x{8} = 0 \ -& -x{1} + 1.22 x{4} - x{5} = 0 \ -& x{9} + 0.222 x{10} - 35.82 = 0 \ -& -3.0 x{7} + x_{10} + 133.0 = 0 \ -& X = [10, 2000] \times [0, 16000] \times [0, 120] \times [0, 5000] \ -& \qquad \times [0, 2000] \times [85, 93] \times [90,9 5] \times [3, 12] \times [1.2, 4] \times [145, 162] \end{align} $

This model can be formulated in Julia as:

using JuMP, EAGO
-
+EAGO - Easy Advanced Global Optimization · EAGO.jl
GitHub
EAGO - Easy Advanced Global Optimization
EAGO is an open-source development environment for robust and global optimization in Julia. See the full README for more information.
PSOR LabCurrent VersionBuild StatusDocumentation
Build Status codecov
EAGO is a deterministic global optimizer designed to address a wide variety of optimization problems, emphasizing nonlinear programs (NLPs), by propagating McCormick relaxations along the factorable structure of each expression in the NLP. Most operators supported by modern automatic differentiation (AD) packages are supported by EAGO and a number utilities for sanitizing native Julia code and generating relaxations on a wide variety of user-defined functions have been included. Currently, EAGO supports problems that have a priori variable bounds defined and have differentiable constraints. That is, problems should be specified in the generic form below:
\[\begin{aligned}
+f^{*} = & \min_{\mathbf y \in Y \subset \mathbb R^{n_{y}}} f(\mathbf y) \\
+{\rm s.t.} \; \; & \mathbf h(\mathbf y) = \mathbf 0 \\
+& \mathbf g(\mathbf y) \leq \mathbf 0 \\
+& Y = [\mathbf y^{L}, \mathbf y^{U}] \in \mathbb{IR}^{n} \\
+& \qquad \mathbf y^{L}, \mathbf y^{U} \in \mathbb R^{n}
+\end{aligned}\]
For each nonlinear term, EAGO makes use of factorable representations to construct bounds and relaxations.
For example, given the function
\[f(x) = x (x - 5) \sin(x),\]
a list is generated and rules for constructing McCormick relaxations are used  to formulate relaxations in the original decision space, $X$ [1]:
\[\begin{aligned}
+v_{1} & = x \\
+v_{2} & = v_{1} - 5 \\
+v_{3} & = \sin(v_{1}) \\
+v_{4} & = v_{1} v_{2} \\
+v_{5} & = v_{4} v_{3} \\
+f(x) & = v_{5} \\
+\end{aligned}\]

+
+
Either these original relaxations, differentiable McCormick relaxations [2], or affine relaxations thereof can be used to construct relaxations of optimization problems useful in branch and bound routines for global optimization. Utilities are included to combine these with algorithms for relaxing implicit functions [3] and forward-reverse propagation of McCormick arithmetic [4].
License
EAGO is licensed under the MIT License.
Installation
EAGO is a registered Julia package that can be installed using the Julia package manager:
import Pkg
+Pkg.add("EAGO")
Use with JuMP
EAGO makes use of JuMP to improve the user's experience in setting up optimization models. Consider the "process" problem instance from [5]:
\[\begin{aligned}
+& \max_{\mathbf x \in X} 0.063 x_{4} x_{7} - 5.04 x_{1} - 0.035 x_{2} - 10 x_{3} - 3.36 x_{2} \\
+{\rm s.t.} \; \; & x_{1} (1.12 + 0.13167 x_{8} - 0.00667 x_{8}^{2}) + x_{4} = 0 \\
+& -0.001 x_{4} x_{9} x_{6} / (98 - x_{6}) + x_{3} = 0 \\
+& -(1.098 x_{8} - 0.038 x_{8}^{2}) - 0.325 x_{6} + x_{7} = 0 \\
+& -(x_{2} + x_{5}) / x_{1} + x_{8} = 0 \\
+& -x_{1} + 1.22 x_{4} - x_{5} = 0 \\
+& x_{9} + 0.222 x_{10} - 35.82 = 0 \\
+& -3.0 x_{7} + x_{10} + 133.0 = 0 \\
+& X = [10, 2000] \times [0, 16000] \times [0, 120] \times [0, 5000] \\
+& \qquad \times [0, 2000] \times [85, 93] \times [90,9 5] \times [3, 12] \times [1.2, 4] \times [145, 162]
+\end{aligned}\]
This model can be formulated in Julia as:
using JuMP
+import EAGO
 # Build model using EAGO's optimizer
-m = Model(EAGO.Optimizer)
-
+model = Model(EAGO.Optimizer)
 # Define bounded variables
-xL = [10.0; 0.0; 0.0; 0.0; 0.0; 85.0; 90.0; 3.0; 1.2; 145.0]
-xU = [2000.0; 16000.0; 120.0; 5000.0; 2000.0; 93.0; 95.0; 12.0; 4.0; 162.0]
-@variable(m, xL[i] <= x[i=1:10] <= xU[i])
-
+xL = [10.0, 0.0, 0.0, 0.0, 0.0, 85.0, 90.0, 3.0, 1.2, 145.0]
+xU = [2000.0, 16000.0, 120.0, 5000.0, 2000.0, 93.0, 95.0, 12.0, 4.0, 162.0]
+@variable(model, xL[i] <= x[i=1:10] <= xU[i])
 # Define nonlinear constraints
-@NLconstraint(m, e1, -x[1]*(1.12 + 0.13167*x[8] - 0.00667*(x[8])^2) + x[4] == 0.0)
-@NLconstraint(m, e3, -0.001*x[4]*x[9]*x[6]/(98.0 - x[6]) + x[3] == 0.0)
-@NLconstraint(m, e4, -(1.098*x[8] - 0.038*(x[8])^2) - 0.325*x[6] + x[7] == 57.425)
-@NLconstraint(m, e5, -(x[2] + x[5])/x[1] + x[8] == 0.0)
-
+@NLconstraints(model, begin
+    -x[1]*(1.12 + 0.13167*x[8] - 0.00667*(x[8])^2) + x[4] == 0.0
+    -0.001*x[4]*x[9]*x[6]/(98.0 - x[6]) + x[3] == 0.0
+    -(1.098*x[8] - 0.038*(x[8])^2) - 0.325*x[6] + x[7] == 57.425
+    -(x[2] + x[5])/x[1] + x[8] == 0.0
+end)
 # Define linear constraints
-@constraint(m, e2, -x[1] + 1.22*x[4] - x[5] == 0.0)
-@constraint(m, e6, x[9] + 0.222*x[10] == 35.82)
-@constraint(m, e7, -3.0*x[7] + x[10] == -133.0)
-
+@constraints(model, begin
+    -x[1] + 1.22*x[4] - x[5] == 0.0
+    x[9] + 0.222*x[10] == 35.82
+    -3.0*x[7] + x[10] == -133.0
+end)
 # Define nonlinear objective
-@NLobjective(m, Max, 0.063*x[4]*x[7] - 5.04*x[1] - 0.035*x[2] - 10*x[3] - 3.36*x[5])
-
+@NLobjective(
+    model, 
+    Max,
+    0.063*x[4]*x[7] - 5.04*x[1] - 0.035*x[2] - 10*x[3] - 3.36*x[5],
+)
 # Solve the optimization problem
-JuMP.optimize!(m)
Documentation
EAGO has numerous features: a solver accessible from JuMP/MathOptInterface (MOI), domain reduction routines, McCormick relaxations, and specialized nonconvex semi-infinite program solvers. A full description of all features can be found on the documentation website. A series of example have been provided in the documentation and in the form of Jupyter Notebooks in the separate EAGO-notebooks repository.
A Cautionary Note on Global Optimization
As a global optimization platform, EAGO's solvers can be used to find solutions of general nonconvex problems with a guaranteed certificate of optimality. However, global solvers suffer from the curse of dimensionality and therefore their performance is outstripped by convex/local solvers. For users interested in large-scale applications, be warned that problems generally larger than a few variables may prove challenging for certain types of global optimization problems.
Citing EAGO
Please cite the following paper when using EAGO. In plain text form this is:
Wilhelm, M.E. and Stuber, M.D. EAGO.jl: easy advanced global optimization in Julia.
+optimize!(model)
Documentation
EAGO has numerous features: a solver accessible from JuMP/MathOptInterface (MOI), domain reduction routines, McCormick relaxations, and specialized nonconvex semi-infinite program solvers. A full description of all features can be found on the documentation website. 
A series of examples have been provided in the documentation and in the form of Jupyter Notebooks in the separate EAGO-notebooks repository.
A Cautionary Note on Global Optimization
As a global optimization platform, EAGO's solvers can be used to find solutions of general nonconvex problems with a guaranteed certificate of optimality. However, global solvers suffer from the curse of dimensionality and therefore their performance is outstripped by convex/local solvers.
For users interested in large-scale applications, be warned that problems generally larger than a few variables may prove challenging for certain types of global optimization problems.
Citing EAGO
Please cite the following paper when using EAGO. In plain text form this is:
Wilhelm, M.E. and Stuber, M.D. EAGO.jl: easy advanced global optimization in Julia.
 Optimization Methods and Software. 37(2): 425-450 (2022). DOI: 10.1080/10556788.2020.1786566
As a BibTeX entry:
@article{doi:10.1080/10556788.2020.1786566,
-author = {Wilhelm, M.E. and Stuber, M.D.},
-title = {EAGO.jl: easy advanced global optimization in Julia},
-journal = {Optimization Methods and Software},
-volume = {37},
-number = {2},
-pages = {425-450},
-year  = {2022},
-publisher = {Taylor & Francis},
-doi = {10.1080/10556788.2020.1786566},
-URL = {https://doi.org/10.1080/10556788.2020.1786566},
-eprint = {https://doi.org/10.1080/10556788.2020.1786566}
-}
References
  1. Mitsos, A., Chachuat, B., and Barton, P.I. McCormick-based relaxations of algorithms. SIAM Journal on Optimization. 20(2): 573–601 (2009).
  2. Khan, K.A., Watson, H.A.J., and Barton, P.I. Differentiable McCormick relaxations. Journal of Global Optimization. 67(4): 687-729 (2017).
  3. Stuber, M.D., Scott, J.K., and Barton, P.I.: Convex and concave relaxations of implicit functions. Optimization Methods and Software 30(3): 424–460 (2015).
  4. Wechsung, A., Scott, J.K., Watson, H.A.J., and Barton, P.I. Reverse propagation of McCormick relaxations. Journal of Global Optimization 63(1): 1-36 (2015).
  5. Bracken, J., and McCormick, G.P. Selected Applications of Nonlinear Programming. John Wiley and Sons, New York (1968).

+    author = {Wilhelm, M.E. and Stuber, M.D.},
+    title = {EAGO.jl: easy advanced global optimization in Julia},
+    journal = {Optimization Methods and Software},
+    volume = {37},
+    number = {2},
+    pages = {425-450},
+    year  = {2022},
+    publisher = {Taylor & Francis},
+    doi = {10.1080/10556788.2020.1786566},
+    URL = {https://doi.org/10.1080/10556788.2020.1786566},
+    eprint = {https://doi.org/10.1080/10556788.2020.1786566}
+}

References

  1. Mitsos, A., Chachuat, B., and Barton, P.I. McCormick-based relaxations of algorithms. SIAM Journal on Optimization. 20(2): 573–601 (2009).
  2. Khan, K.A., Watson, H.A.J., and Barton, P.I. Differentiable McCormick relaxations. Journal of Global Optimization. 67(4): 687–729 (2017).
  3. Stuber, M.D., Scott, J.K., and Barton, P.I.: Convex and concave relaxations of implicit functions. Optimization Methods and Software 30(3): 424–460 (2015).
  4. Wechsung, A., Scott, J.K., Watson, H.A.J., and Barton, P.I. Reverse propagation of McCormick relaxations. Journal of Global Optimization 63(1): 1–36 (2015).
  5. Bracken, J., and McCormick, G.P. Selected Applications of Nonlinear Programming. John Wiley and Sons, New York (1968).
diff --git a/dev/mccormick/implicit/index.html b/dev/mccormick/implicit/index.html index 72f8f9f4..26dca2d1 100644 --- a/dev/mccormick/implicit/index.html +++ b/dev/mccormick/implicit/index.html @@ -9,4 +9,4 @@

An operator that cuts the x object using the y bounds in a differentiable or nonsmooth fashion to achieve a composite relaxation within y.

source
McCormick.gen_expansion_params! — Function
gen_expansion_params!(d)
 gen_expansion_params!(d, interval_bnds)

Constructs parameters need to compute relaxations of h.

source
McCormick.populate_affine! — Function
populate_affine!(d, interval_bnds)
-

Populates x_mc, xa_mc, xA_mc, and z_mc with affine bounds.

source
+

Populates x_mc, xa_mc, xA_mc, and z_mc with affine bounds.

source diff --git a/dev/mccormick/operators/index.html b/dev/mccormick/operators/index.html index 71470300..08b656b6 100644 --- a/dev/mccormick/operators/index.html +++ b/dev/mccormick/operators/index.html @@ -1,2 +1,2 @@ -Currently Supported Operators · EAGO.jl
GitHub

Currently Supported Operators

The operators currently supported are listed below. The operators with a check box have been subject to a large degree of scrutiny and have been implemented for both forward and reverse McCormick relaxations (Wechsung2015). Each McCormick object is associated with a parameter T <: RelaxTag which is either NS for nonsmooth relaxations (Mitsos2009, Scott2011), MV for multivariate relaxations (Tsoukalas2014, Najman2017), or Diff for differentiable relaxations (Khan2016, Khan2018, Khan2019). Conversion between NS, MV, and Diff relax tags is not currently supported. Convex and concave envelopes are used to compute relaxations of univariate functions.

Univariate McCormick Operators

Arbitrarily differentiable relaxations can be constructed for the following operators:

  • Inverse (inv)
  • Logarithms (log, log2, log10)
  • Exponential Functions (exp, exp2, exp10)
  • Square Root (sqrt)
  • Absolute Value (abs)

Both nonsmooth and Whitney-1 (once differentiable) relaxations are supported for the following operators:

  • Step Functions (step, sign)
  • Trigonometric Functions (sin, cos, tan)
  • Inverse Trigonometric Functions (asin, acos, atan)
  • Hyperbolic Functions (sinh, cosh, tanh)
  • Inverse Hyperbolic Functions (asinh, acosh, atanh)
  • Common Activation Functions (relu, leaky_relu, param_relu, sigmoid, bisigmoid, softsign, softplus, maxtanh, pentanh, gelu, elu, selu, swish)
  • Special Functions (erf)

Bivariate McCormick Operators

The following bivariate operators are supported for two MC objects. Both nonsmooth and Whitney-1 (once differentiable) relaxations are supported.

  • Multiplication (*)
  • Division (/)

Arbitrarily differentiable relaxations can be constructed for the following operators:

  • Addition (+)
  • Subtraction (-)
  • Minimization (min)
  • Maximization (max)

Common Subexpressions

The following functions can be used in place of common subexpressions encountered in optimization and will result in improved performance (in each case, the standard McCormick composition rules are often more expansive).

McCormick.xexpax — Function

expax

The expax function is defined as expax(x, a) = x*exp(a*x).

Form defined in Najman, Jaromił, Dominik Bongartz, and Alexander Mitsos. "Relaxations of thermodynamic property and costing models in process engineering." Computers & Chemical Engineering 130 (2019): 106571.

source
McCormick.arh — Function

arh

The arrhenius function arh is defined as arh(x) = exp(-k/x).

source

Bound Setting Functions

The following functions are used to specify that known bounds on a subexpression exist and that the relaxation/interval bounds propagated should make use of this information. The utility functions can be helpful in avoiding domain violations that arise due to the overly expansive nature of composite relaxations. Improper use of these functions may lead to cases in which the resulting relaxations are empty, so the user is encouraged to use discretion.

McCormick.positive — Function

positive(x::MC)

Sets the lower interval bound and the convex relaxation of x to a value of at least McCormick.MC_DOMAIN_TOL. (Sub)gradients are adjusted appropriately.

source
McCormick.negative — Function

negative(x::MC)

Sets the upper interval bound and the concave relaxation of x to a value of at most -McCormick.MC_DOMAIN_TOL. (Sub)gradients are adjusted appropriately.

source
McCormick.lower_bnd — Function

lower_bnd(x::MC, lb::Float64)

Sets the lower interval bound and the convex relaxation of x to a value of at least lb. (Sub)gradients are adjusted appropriately.

source
McCormick.upper_bnd — Function

upper_bnd(x::MC, ub)

Sets the upper interval bound and the concave relaxation of x to a value of at most ub. (Sub)gradients are adjusted appropriately.

source
McCormick.bnd — Function

bnd(x::MC, lb, ub)

Sets the lower interval bound and the convex relaxation of x to a value of at least lb. Sets the upper interval bound and the concave relaxation of x to a value of at most ub. (Sub)gradients are adjusted appropriately.

source

Specialized Activation Functions

McCormick.pentanh — Function

pentanh

The pentanh activation function pentanh(x) = x > 0.0 ? tanh(x) : tanh(0.25*x).

source
McCormick.leaky_relu — Function

leaky_relu

The leaky Rectified Linear Unit activation function leaky_relu(x) = max(x, 0.01x).

source
McCormick.param_relu — Function

param_relu

The parametric Rectified Linear Unit activation function param_relu(x, α) = (max(x, αx) with α in [0,1].

source

References

  • Khan KA, Watson HAJ, Barton PI (2017). Differentiable McCormick relaxations. Journal of Global Optimization, 67(4): 687-729.
  • Khan KA, Wilhelm ME, Stuber MD, Cao H, Watson HAJ, Barton PI (2018). Corrections to: Differentiable McCormick relaxations. Journal of Global Optimization, 70(3): 705-706.
  • Khan KA (2019). Whitney differentiability of optimal-value functions for bound-constrained convex programming problems. Optimization, 68(2-3): 691-711
  • Mitsos A, Chachuat B, and Barton PI. (2009). McCormick-based relaxations of algorithms. SIAM Journal on Optimization, 20(2): 573–601.
  • Najman J, Bongratz D, Tsoukalas A, and Mitsos A (2017). Erratum to: Multivariate McCormick relaxations. Journal of Global Optimization, 68: 219-225.
  • Scott JK, Stuber MD, and Barton PI. (2011). Generalized McCormick relaxations. Journal of Global Optimization, 51(4): 569–606.
  • Stuber MD, Scott JK, Barton PI (2015). Convex and concave relaxations of implicit functions. Optim. Methods Softw., 30(3): 424–460
  • Tsoukalas A and Mitsos A (2014). Multivariate McCormick Relaxations. Journal of Global Optimization, 59:633–662.
  • Wechsung A, Scott JK, Watson HAJ, and Barton PI. (2015). Reverse propagation of McCormick relaxations. Journal of Global Optimization, 63(1): 1-36.
+Currently Supported Operators · EAGO.jl
GitHub

Currently Supported Operators

The operators currently supported are listed below. The operators with a check box have been subject to a large degree of scrutiny and have been implemented for both forward and reverse McCormick relaxations (Wechsung2015). Each McCormick object is associated with a parameter T <: RelaxTag which is either NS for nonsmooth relaxations (Mitsos2009, Scott2011), MV for multivariate relaxations (Tsoukalas2014, Najman2017), or Diff for differentiable relaxations (Khan2016, Khan2018, Khan2019). Conversion between NS, MV, and Diff relax tags is not currently supported. Convex and concave envelopes are used to compute relaxations of univariate functions.

Univariate McCormick Operators

Arbitrarily differentiable relaxations can be constructed for the following operators:

  • Inverse (inv)
  • Logarithms (log, log2, log10)
  • Exponential Functions (exp, exp2, exp10)
  • Square Root (sqrt)
  • Absolute Value (abs)

Both nonsmooth and Whitney-1 (once differentiable) relaxations are supported for the following operators:

  • Step Functions (step, sign)
  • Trigonometric Functions (sin, cos, tan)
  • Inverse Trigonometric Functions (asin, acos, atan)
  • Hyperbolic Functions (sinh, cosh, tanh)
  • Inverse Hyperbolic Functions (asinh, acosh, atanh)
  • Common Activation Functions (relu, leaky_relu, param_relu, sigmoid, bisigmoid, softsign, softplus, maxtanh, pentanh, gelu, elu, selu, swish)
  • Special Functions (erf)

Bivariate McCormick Operators

The following bivariate operators are supported for two MC objects. Both nonsmooth and Whitney-1 (once differentiable) relaxations are supported.

  • Multiplication (*)
  • Division (/)

Arbitrarily differentiable relaxations can be constructed for the following operators:

  • Addition (+)
  • Subtraction (-)
  • Minimization (min)
  • Maximization (max)

Common Subexpressions

The following functions can be used in place of common subexpressions encountered in optimization and will result in improved performance (in each case, the standard McCormick composition rules are often more expansive).

McCormick.xexpax — Function

expax

The expax function is defined as expax(x, a) = x*exp(a*x).

Form defined in Najman, Jaromił, Dominik Bongartz, and Alexander Mitsos. "Relaxations of thermodynamic property and costing models in process engineering." Computers & Chemical Engineering 130 (2019): 106571.

source
McCormick.arh — Function

arh

The arrhenius function arh is defined as arh(x) = exp(-k/x).

source

Bound Setting Functions

The following functions are used to specify that known bounds on a subexpression exist and that the relaxation/interval bounds propagated should make use of this information. The utility functions can be helpful in avoiding domain violations that arise due to the overly expansive nature of composite relaxations. Improper use of these functions may lead to cases in which the resulting relaxations are empty, so the user is encouraged to use discretion.

McCormick.positive — Function

positive(x::MC)

Sets the lower interval bound and the convex relaxation of x to a value of at least McCormick.MC_DOMAIN_TOL. (Sub)gradients are adjusted appropriately.

source
McCormick.negative — Function

negative(x::MC)

Sets the upper interval bound and the concave relaxation of x to a value of at most -McCormick.MC_DOMAIN_TOL. (Sub)gradients are adjusted appropriately.

source
McCormick.lower_bnd — Function

lower_bnd(x::MC, lb::Float64)

Sets the lower interval bound and the convex relaxation of x to a value of at least lb. (Sub)gradients are adjusted appropriately.

source
McCormick.upper_bnd — Function

upper_bnd(x::MC, ub)

Sets the upper interval bound and the concave relaxation of x to a value of at most ub. (Sub)gradients are adjusted appropriately.

source
McCormick.bnd — Function

bnd(x::MC, lb, ub)

Sets the lower interval bound and the convex relaxation of x to a value of at least lb. Sets the upper interval bound and the concave relaxation of x to a value of at most ub. (Sub)gradients are adjusted appropriately.

source

Specialized Activation Functions

McCormick.pentanh — Function

pentanh

The pentanh activation function pentanh(x) = x > 0.0 ? tanh(x) : tanh(0.25*x).

source
McCormick.leaky_relu — Function

leaky_relu

The leaky Rectified Linear Unit activation function leaky_relu(x) = max(x, 0.01x).

source
McCormick.param_relu — Function

param_relu

The parametric Rectified Linear Unit activation function param_relu(x, α) = (max(x, αx) with α in [0,1].

source

References

  • Khan KA, Watson HAJ, Barton PI (2017). Differentiable McCormick relaxations. Journal of Global Optimization, 67(4): 687-729.
  • Khan KA, Wilhelm ME, Stuber MD, Cao H, Watson HAJ, Barton PI (2018). Corrections to: Differentiable McCormick relaxations. Journal of Global Optimization, 70(3): 705-706.
  • Khan KA (2019). Whitney differentiability of optimal-value functions for bound-constrained convex programming problems. Optimization, 68(2-3): 691-711
  • Mitsos A, Chachuat B, and Barton PI. (2009). McCormick-based relaxations of algorithms. SIAM Journal on Optimization, 20(2): 573–601.
  • Najman J, Bongratz D, Tsoukalas A, and Mitsos A (2017). Erratum to: Multivariate McCormick relaxations. Journal of Global Optimization, 68: 219-225.
  • Scott JK, Stuber MD, and Barton PI. (2011). Generalized McCormick relaxations. Journal of Global Optimization, 51(4): 569–606.
  • Stuber MD, Scott JK, Barton PI (2015). Convex and concave relaxations of implicit functions. Optim. Methods Softw., 30(3): 424–460
  • Tsoukalas A and Mitsos A (2014). Multivariate McCormick Relaxations. Journal of Global Optimization, 59:633–662.
  • Wechsung A, Scott JK, Watson HAJ, and Barton PI. (2015). Reverse propagation of McCormick relaxations. Journal of Global Optimization, 63(1): 1-36.
diff --git a/dev/mccormick/overview/index.html b/dev/mccormick/overview/index.html index 9ae93667..cf240a84 100644 --- a/dev/mccormick/overview/index.html +++ b/dev/mccormick/overview/index.html @@ -1,2 +1,2 @@ -Overview · EAGO.jl
GitHub

Overview

EAGO provides a library of McCormick relaxations in native Julia code. The EAGO optimizer supports relaxing functions using nonsmooth McCormick relaxations (Mitsos2009, Scott2011), smooth McCormick relaxations (Khan2016, Khan2018, Khan2019), and multi-variant McCormick relaxations (Tsoukalas2014; a variant of subgradient-based interval refinement (Najman2017)). For functions with arbitrarily differentiable relaxations, the differentiable constant μ can be modified by adjusting a constant value in the package. Additionally, validated and nonvalidated interval bounds are supported via IntervalArithmetic.jl which is reexported. The basic McCormick operator and reverse McCormick operator (Wechsung2015) libraries are included in two dependent subpackages which can loaded and used independently:

NaN Numerics

When a relaxation is computed at an undefined point or over an unbounded domain, the resulting relaxation is defined as "not a number" (NaN) rather than throwing an error. This allows algorithms to check for these cases without resorting to try-catch statements. Moreover, when the interval domain is extensive enough to cause a domain violation, an x::MC structure is returned that satisfies isnan(x) === true.

References

  • Khan KA, Watson HAJ, Barton PI (2017). Differentiable McCormick relaxations. Journal of Global Optimization, 67(4): 687-729.
  • Khan KA, Wilhelm ME, Stuber MD, Cao H, Watson HAJ, Barton PI (2018). Corrections to: Differentiable McCormick relaxations. Journal of Global Optimization, 70(3): 705-706.
  • Khan KA (2019). Whitney differentiability of optimal-value functions for bound-constrained convex programming problems. Optimization, 68(2-3): 691-711
  • Mitsos A, Chachuat B, and Barton PI. (2009). McCormick-based relaxations of algorithms. SIAM Journal on Optimization, 20(2): 573–601.
  • Najman J, Bongratz D, Tsoukalas A, and Mitsos A (2017). Erratum to: Multivariate McCormick relaxations. Journal of Global Optimization, 68: 219-225.
  • Scott JK, Stuber MD, and Barton PI. (2011). Generalized McCormick relaxations. Journal of Global Optimization, 51(4): 569–606.
  • Stuber MD, Scott JK, Barton PI (2015). Convex and concave relaxations of implicit functions. Optim. Methods Softw., 30(3): 424–460
  • Tsoukalas A and Mitsos A (2014). Multivariate McCormick Relaxations. Journal of Global Optimization, 59: 633–662.
  • Wechsung A, Scott JK, Watson HAJ, and Barton PI. (2015). Reverse propagation of McCormick relaxations. Journal of Global Optimization, 63(1): 1-36.
+Overview · EAGO.jl
GitHub

Overview

EAGO provides a library of McCormick relaxations in native Julia code. The EAGO optimizer supports relaxing functions using nonsmooth McCormick relaxations (Mitsos2009, Scott2011), smooth McCormick relaxations (Khan2016, Khan2018, Khan2019), and multi-variant McCormick relaxations (Tsoukalas2014; a variant of subgradient-based interval refinement (Najman2017)). For functions with arbitrarily differentiable relaxations, the differentiable constant μ can be modified by adjusting a constant value in the package. Additionally, validated and nonvalidated interval bounds are supported via IntervalArithmetic.jl which is reexported. The basic McCormick operator and reverse McCormick operator (Wechsung2015) libraries are included in two dependent subpackages which can loaded and used independently:

NaN Numerics

When a relaxation is computed at an undefined point or over an unbounded domain, the resulting relaxation is defined as "not a number" (NaN) rather than throwing an error. This allows algorithms to check for these cases without resorting to try-catch statements. Moreover, when the interval domain is extensive enough to cause a domain violation, an x::MC structure is returned that satisfies isnan(x) === true.

References

  • Khan KA, Watson HAJ, Barton PI (2017). Differentiable McCormick relaxations. Journal of Global Optimization, 67(4): 687-729.
  • Khan KA, Wilhelm ME, Stuber MD, Cao H, Watson HAJ, Barton PI (2018). Corrections to: Differentiable McCormick relaxations. Journal of Global Optimization, 70(3): 705-706.
  • Khan KA (2019). Whitney differentiability of optimal-value functions for bound-constrained convex programming problems. Optimization, 68(2-3): 691-711
  • Mitsos A, Chachuat B, and Barton PI. (2009). McCormick-based relaxations of algorithms. SIAM Journal on Optimization, 20(2): 573–601.
  • Najman J, Bongratz D, Tsoukalas A, and Mitsos A (2017). Erratum to: Multivariate McCormick relaxations. Journal of Global Optimization, 68: 219-225.
  • Scott JK, Stuber MD, and Barton PI. (2011). Generalized McCormick relaxations. Journal of Global Optimization, 51(4): 569–606.
  • Stuber MD, Scott JK, Barton PI (2015). Convex and concave relaxations of implicit functions. Optim. Methods Softw., 30(3): 424–460
  • Tsoukalas A and Mitsos A (2014). Multivariate McCormick Relaxations. Journal of Global Optimization, 59: 633–662.
  • Wechsung A, Scott JK, Watson HAJ, and Barton PI. (2015). Reverse propagation of McCormick relaxations. Journal of Global Optimization, 63(1): 1-36.
diff --git a/dev/mccormick/type/index.html b/dev/mccormick/type/index.html index b2414b5d..888f0a7b 100644 --- a/dev/mccormick/type/index.html +++ b/dev/mccormick/type/index.html @@ -63,4 +63,4 @@ envp1::Float64, envp2::Float64 ) -> Float64 -

Defines a local 1D golden section method to solve for the root of f between the bounds xL and xU using x0 as a starting point. Define iteration used in golden section method. The inputs envp1 and envp2 are the envelope calculation parameters.

source

(Under Development) MCNoGrad

A handful of applications make use of McCormick relaxations directly without the need for subgradients. We are currently adding support for a McCormick struct which omits subgradient propagation in favor of return a MCNoGrad object and associated derivative information. This is currently under development and likely lacking key functionality.

McCormick.MCNoGrad — Type
struct MCNoGrad <: Real

MCNoGrad <: Real is a McCormick structure without RelaxType Tag or subgradients. This structure is used for source-code transformation approaches to constructing McCormick relaxations. Methods definitions and calls should specify the relaxation type used (i.e.) +(::NS, x::MCNoGrad, y::MCNoGrad).... Moreover, the kernel associated with this returns all intermediate calculations necessary to compute subgradient information whereas the overloading calculation simply returns the MCNoGrad object. For univariate calculations without tiepoints such as we log2(::NS, x::MCNoGrad)::MCNoGrad whereas log2_kernel(::NS, x::MCNoGrad, ::Bool) = (::MCNoGrad, cv_id::Int, cc_id::Int, dcv, dcc). Univariate NS functions follow convention (MCNoGrad, cvid, ccid, dcv, dcc, tp1cv, tp1cc, .... tpncv, tpncc) where cv_id is the subgradient selected (1 = cv, 2 = cc, 3 = 0), dcv and dcc are derivatives (or elements of subdifferential) of the outside function evaluated per theorem at the point being evaluated and tpicv, tpicc are the ith tiepoints associated with computing the envelope of the outside function. .

  • cv::Float64: Convex relaxation

  • cc::Float64: Concave relaxation

  • Intv::Interval{Float64}: Interval bounds

  • cnst::Bool: Boolean indicating whether the relaxations are constant over the domain. True if bounding an interval/constant. False, otherwise. This may change over the course of a calculation cnst for zero(x) is true even if x.cnst is false.

source
McCormick.MCNoGrad — Method

MCNoGrad(y::Float64)

Constructs McCormick relaxation with convex relaxation equal to y and concave relaxation equal to y.

source
McCormick.MCNoGrad — Method

MCNoGrad(y::Interval{Float64})

Constructs McCormick relaxation with convex relaxation equal to y.lo and concave relaxation equal to y.hi.

source
McCormick.MCNoGrad — Method

MCNoGrad(cv::Float64, cc::Float64)

Constructs McCormick relaxation with convex relaxation equal to cv and concave relaxation equal to cc.

source
+

Defines a local 1D golden section method to solve for the root of f between the bounds xL and xU using x0 as a starting point. Define iteration used in golden section method. The inputs envp1 and envp2 are the envelope calculation parameters.

source

(Under Development) MCNoGrad

A handful of applications make use of McCormick relaxations directly without the need for subgradients. We are currently adding support for a McCormick struct which omits subgradient propagation in favor of return a MCNoGrad object and associated derivative information. This is currently under development and likely lacking key functionality.

McCormick.MCNoGrad — Type
struct MCNoGrad <: Real

MCNoGrad <: Real is a McCormick structure without RelaxType Tag or subgradients. This structure is used for source-code transformation approaches to constructing McCormick relaxations. Methods definitions and calls should specify the relaxation type used (i.e.) +(::NS, x::MCNoGrad, y::MCNoGrad).... Moreover, the kernel associated with this returns all intermediate calculations necessary to compute subgradient information whereas the overloading calculation simply returns the MCNoGrad object. For univariate calculations without tiepoints such as we log2(::NS, x::MCNoGrad)::MCNoGrad whereas log2_kernel(::NS, x::MCNoGrad, ::Bool) = (::MCNoGrad, cv_id::Int, cc_id::Int, dcv, dcc). Univariate NS functions follow convention (MCNoGrad, cvid, ccid, dcv, dcc, tp1cv, tp1cc, .... tpncv, tpncc) where cv_id is the subgradient selected (1 = cv, 2 = cc, 3 = 0), dcv and dcc are derivatives (or elements of subdifferential) of the outside function evaluated per theorem at the point being evaluated and tpicv, tpicc are the ith tiepoints associated with computing the envelope of the outside function. .

  • cv::Float64: Convex relaxation

  • cc::Float64: Concave relaxation

  • Intv::Interval{Float64}: Interval bounds

  • cnst::Bool: Boolean indicating whether the relaxations are constant over the domain. True if bounding an interval/constant. False, otherwise. This may change over the course of a calculation cnst for zero(x) is true even if x.cnst is false.

source
McCormick.MCNoGrad — Method

MCNoGrad(y::Float64)

Constructs McCormick relaxation with convex relaxation equal to y and concave relaxation equal to y.

source
McCormick.MCNoGrad — Method

MCNoGrad(y::Interval{Float64})

Constructs McCormick relaxation with convex relaxation equal to y.lo and concave relaxation equal to y.hi.

source
McCormick.MCNoGrad — Method

MCNoGrad(cv::Float64, cc::Float64)

Constructs McCormick relaxation with convex relaxation equal to cv and concave relaxation equal to cc.

source
diff --git a/dev/mccormick/usage/index.html b/dev/mccormick/usage/index.html index 3c79a6a5..e2f8d227 100644 --- a/dev/mccormick/usage/index.html +++ b/dev/mccormick/usage/index.html @@ -44,4 +44,4 @@ cv = fMC.cv # Convex relaxation cc = fMC.cc # Concave relaxation end -end

Figure_3

+end

Figure_3

diff --git a/dev/news/index.html b/dev/news/index.html index d98e3424..9ef37348 100644 --- a/dev/news/index.html +++ b/dev/news/index.html @@ -1,2 +1,2 @@ -News · EAGO.jl
GitHub

News for EAGO Releases

v0.8.1 (June 15, 2023)

  • Resolved an issue where integer and binary variables would sometimes throw a MathOptInterface.UpperBoundAlreadySet error.
  • Added the function unbounded_check! which warns users if they are missing variable bounds and sets them to +/- 1E10 by default.
    • Added an EAGO parameter unbounded_check which defaults to true and enables unbounded_check!.
  • Bumped requirement for PrettyTables.jl to v2+ to accommodate the latest version of DataFrames.jl.

v0.8.0 (June 12, 2023)

  • Updated EAGO for compatibility with the nonlinear expression API changes introduced in JuMP v1.2: https://discourse.julialang.org/t/ann-upcoming-refactoring-of-jumps-nonlinear-api/83052.
    • EAGO now uses the MOI.Nonlinear submodule instead of JuMP._Derivatives.
    • Models, nodes, expressions, constraints, and operators are now compatible with MOI.
  • Added logic and comparison operators to EAGO.OperatorRegistry.

v0.7.3 (April 11, 2023)

  • Bumped DocStringExtensions.jl compatibility.

v0.7.2 (November 22, 2022)

  • Added support for Julia 1.7.
  • Bumped NaNMath.jl compatibility.
  • Added help? information for various functions and structures.
  • Updated documentation and some formatting.

v0.7.1 (June 26, 2022)

  • Added the function print_problem_summary, an internal script used to display all constraints, objectives in a linear program which is added to functions for debug purposes while writing code.
  • Adjusted default EAGOParameters.
    • branch_cvx_factor: 0.5 => 0.25
    • branch_offset: 0.2 => 0.15
    • time_limit and _time_left: 1000.0 => 3600.0
    • obbt_depth: 0 => 6
    • obbt_repetitions: 1 => 3
    • cut_tolerance_rel: 1E-2 => 1E-3
  • Adjusted Ipopt.Optimizer attributes.
    • max_iter: 20000 => 10000
    • acceptable_iter: 10000 => 1000
  • Excluded test_quadratic_nonconvex_constraint_basic from MOI tests.
  • Restricted JuMP compatibility to 1.0.0 - 1.1.1.

v0.7.0 (March 28, 2022)

  • Added envelopes of activation functions: xabsx, logcosh
  • Added variations of estimator_extrema, estimator_under, and estimator_over functions to EAGO for bilinear relaxations.
  • Moved various functions and related structures to new files.
  • Added RelaxCache structure to hold relaxed problem information.
  • Updated forward and reverse propagation.
  • Added PrettyTables.jl.
  • Added test examples.
  • Added a memory allocation analysis.
  • Updated documentation.

v0.6.1 (March 4, 2021)

  • Minor update to tests.

v0.6.0 (February 19, 2021)

  • License changed from CC BY-NC-SA 4.0 to MIT.
  • Fix deprecated Ipopt constructor.
  • Fix discrepancy between the returned objective value and the objective evaluated at the solution.
  • Dramatically decrease allocates and first-run performance of SIP routines.
  • Add two algorithms which modify SIPRes detailed in Djelassi, H. and Mitsos A. 2017.
  • Fix objective interval fallback function.
  • New SIP interface with extendable subroutines.
  • Fix x^y relaxation bug.
  • Add issues template.
  • Add SIP subroutine documentation.

v0.5.2 (November 18, 2020)

  • Fix user specified branching variables.

v0.5.1 (November 18, 2020)

  • Support for Julia ~1 (with limited functionality for Julia 1.0 and 1.1).

v0.5.0 (November 18, 2020)

  • Introduces the register_eago_operators!(m::JuMP.Model) which can be used to register all nonstandard nonlinear terms used in EAGO in any JuMP model.
  • Introduces positive, negative, lower_bnd, upper_bnd, and bnd functions which can be used to enforce bounds on intermediate terms in nonlinear expressions (EAGO.Optimizer only).
  • Adds envelopes: abs2, sinpi, cospi, fma, cbrt
  • Adds envelopes and functions: xlogx
  • Adds envelopes of special functions: erf, erfc, erfinv, erfcinv
  • Adds envelopes of activation functions: relu, gelu, elu, selu, swish, sigmoid, softsign, softplus, bisigmoid, pentanh, leaky_relu, param_relu
  • Error messages in sip_explicit have been made more transparent.
  • Fixes some issues with documentation image rendering and links.
  • Drops appveyor CI and Travis CI in favor of GitHub Actions.

v0.4.2 (August 28, 2020)

  • Support for Julia 1.5.

v0.4.1 (June 17, 2020)

  • Minor bug fixes.

v0.4.0 (June 12, 2020)

  • Support for new MOI/JuMP RawParameter input and a number of new attributes.
  • Separates McCormick and ReverseMcCormick libraries (now McCormick.jl and ReverseMcCormick.jl) from main package. McCormick.jl is reexported.
  • Relaxation calculations now return NaN values on a domain violation.
  • Tolerance based validation of cuts has been added to generate numerically safe cuts.
  • Significantly simplify internal codebase for EAGO.Optimizer (no changes to API): fully decouples input problem specifications from the formulation used internally, stack only stores variables that are branched on, and a number of internal rearrangements to clearly delineate different routines.
  • Add problem classification preprocessing that throws to simpler routines if LP problem types are detected (enables future support for SOCP, MILP, MISOCP, and Convex forms).
  • Fix multiple bugs and add more transparent error codes.

v0.3.1 (January 29, 2020)

  • Add unit tests.
  • Support for Julia 1.3.
  • Fix IntervalContractors.jl dependency issue.

v0.3.0 (November 5, 2019)

This update is intended to be the last to create a large number of breaking changes to the EAGO API. Please review the use cases provided in the documentation to update examples.

  • A number of performance improvements have been made to the underlying McCormick relaxation library.
  • The optimizer used to construct relaxations is now modified in place.
  • All subproblem storage has been moved to the Optimizer object and storage types (e.g. LowerInfo) have been removed.
  • A BinaryMinMaxHeap structure is now used to store nodes.
  • Speed and aesthetics for logging and printing utilities have been updated.
  • Subroutines are now customized by creating a subtype of ExtensionType and defining subroutines which dispatch on this new structure.
  • Parametric interval methods and the Implicit optimizer have been move to a separate package (to be tagged shortly).
  • JIT compilation time has been reduced substantially.
  • Support for silent tag and time limits.

v0.2.1 (July 7, 2019)

  • Bug fix for explicit SIP solving routine that occurred for uncertainty sets of dimension greater than 1.
  • Bug fix for MOI.MAX_SENSE (max objective sense).

v0.2.0 (June 14, 2019)

This update creates a number of breaking changes to the EAGO API. Please review the use cases provided in the documentation to update examples.

  • Updated to support Julia 1.0+, MathOptInterface (MOI), and MOI construction of subproblems.
  • Additional domain reduction routines available.
  • Support for specialized handling of linear and quadratic terms.
  • Significant performance improvements due to pre-allocation of Wengert tapes and MOI support.
  • A more intuitive API for McCormick relaxation construction.

v0.1.2 (June 20, 2018)

  • Significant speed and functionality updates.

v0.1.1 (June 7, 2018)

  • Initial release of combined EAGO packages.

v0.1.0 (April 10, 2018)

  • Main global solver release.
+News · EAGO.jl
GitHub

News for EAGO Releases

v0.8.1 (June 15, 2023)

  • Resolved an issue where integer and binary variables would sometimes throw a MathOptInterface.UpperBoundAlreadySet error.
  • Added the function unbounded_check! which warns users if they are missing variable bounds and sets them to +/- 1E10 by default.
    • Added an EAGO parameter unbounded_check which defaults to true and enables unbounded_check!.
  • Bumped requirement for PrettyTables.jl to v2+ to accommodate the latest version of DataFrames.jl.

v0.8.0 (June 12, 2023)

  • Updated EAGO for compatibility with the nonlinear expression API changes introduced in JuMP v1.2: https://discourse.julialang.org/t/ann-upcoming-refactoring-of-jumps-nonlinear-api/83052.
    • EAGO now uses the MOI.Nonlinear submodule instead of JuMP._Derivatives.
    • Models, nodes, expressions, constraints, and operators are now compatible with MOI.
  • Added logic and comparison operators to EAGO.OperatorRegistry.

v0.7.3 (April 11, 2023)

  • Bumped DocStringExtensions.jl compatibility.

v0.7.2 (November 22, 2022)

  • Added support for Julia 1.7.
  • Bumped NaNMath.jl compatibility.
  • Added help? information for various functions and structures.
  • Updated documentation and some formatting.

v0.7.1 (June 26, 2022)

  • Added the function print_problem_summary, an internal script used to display all constraints, objectives in a linear program which is added to functions for debug purposes while writing code.
  • Adjusted default EAGOParameters.
    • branch_cvx_factor: 0.5 => 0.25
    • branch_offset: 0.2 => 0.15
    • time_limit and _time_left: 1000.0 => 3600.0
    • obbt_depth: 0 => 6
    • obbt_repetitions: 1 => 3
    • cut_tolerance_rel: 1E-2 => 1E-3
  • Adjusted Ipopt.Optimizer attributes.
    • max_iter: 20000 => 10000
    • acceptable_iter: 10000 => 1000
  • Excluded test_quadratic_nonconvex_constraint_basic from MOI tests.
  • Restricted JuMP compatibility to 1.0.0 - 1.1.1.

v0.7.0 (March 28, 2022)

  • Added envelopes of activation functions: xabsx, logcosh
  • Added variations of estimator_extrema, estimator_under, and estimator_over functions to EAGO for bilinear relaxations.
  • Moved various functions and related structures to new files.
  • Added RelaxCache structure to hold relaxed problem information.
  • Updated forward and reverse propagation.
  • Added PrettyTables.jl.
  • Added test examples.
  • Added a memory allocation analysis.
  • Updated documentation.

v0.6.1 (March 4, 2021)

  • Minor update to tests.

v0.6.0 (February 19, 2021)

  • License changed from CC BY-NC-SA 4.0 to MIT.
  • Fix deprecated Ipopt constructor.
  • Fix discrepancy between the returned objective value and the objective evaluated at the solution.
  • Dramatically decrease allocates and first-run performance of SIP routines.
  • Add two algorithms which modify SIPRes detailed in Djelassi, H. and Mitsos A. 2017.
  • Fix objective interval fallback function.
  • New SIP interface with extendable subroutines.
  • Fix x^y relaxation bug.
  • Add issues template.
  • Add SIP subroutine documentation.

v0.5.2 (November 18, 2020)

  • Fix user specified branching variables.

v0.5.1 (November 18, 2020)

  • Support for Julia ~1 (with limited functionality for Julia 1.0 and 1.1).

v0.5.0 (November 18, 2020)

  • Introduces the register_eago_operators!(m::JuMP.Model) which can be used to register all nonstandard nonlinear terms used in EAGO in any JuMP model.
  • Introduces positive, negative, lower_bnd, upper_bnd, and bnd functions which can be used to enforce bounds on intermediate terms in nonlinear expressions (EAGO.Optimizer only).
  • Adds envelopes: abs2, sinpi, cospi, fma, cbrt
  • Adds envelopes and functions: xlogx
  • Adds envelopes of special functions: erf, erfc, erfinv, erfcinv
  • Adds envelopes of activation functions: relu, gelu, elu, selu, swish, sigmoid, softsign, softplus, bisigmoid, pentanh, leaky_relu, param_relu
  • Error messages in sip_explicit have been made more transparent.
  • Fixes some issues with documentation image rendering and links.
  • Drops appveyor CI and Travis CI in favor of GitHub Actions.

v0.4.2 (August 28, 2020)

  • Support for Julia 1.5.

v0.4.1 (June 17, 2020)

  • Minor bug fixes.

v0.4.0 (June 12, 2020)

  • Support for new MOI/JuMP RawParameter input and a number of new attributes.
  • Separates McCormick and ReverseMcCormick libraries (now McCormick.jl and ReverseMcCormick.jl) from main package. McCormick.jl is reexported.
  • Relaxation calculations now return NaN values on a domain violation.
  • Tolerance based validation of cuts has been added to generate numerically safe cuts.
  • Significantly simplify internal codebase for EAGO.Optimizer (no changes to API): fully decouples input problem specifications from the formulation used internally, stack only stores variables that are branched on, and a number of internal rearrangements to clearly delineate different routines.
  • Add problem classification preprocessing that throws to simpler routines if LP problem types are detected (enables future support for SOCP, MILP, MISOCP, and Convex forms).
  • Fix multiple bugs and add more transparent error codes.

v0.3.1 (January 29, 2020)

  • Add unit tests.
  • Support for Julia 1.3.
  • Fix IntervalContractors.jl dependency issue.

v0.3.0 (November 5, 2019)

This update is intended to be the last to create a large number of breaking changes to the EAGO API. Please review the use cases provided in the documentation to update examples.

  • A number of performance improvements have been made to the underlying McCormick relaxation library.
  • The optimizer used to construct relaxations is now modified in place.
  • All subproblem storage has been moved to the Optimizer object and storage types (e.g. LowerInfo) have been removed.
  • A BinaryMinMaxHeap structure is now used to store nodes.
  • Speed and aesthetics for logging and printing utilities have been updated.
  • Subroutines are now customized by creating a subtype of ExtensionType and defining subroutines which dispatch on this new structure.
  • Parametric interval methods and the Implicit optimizer have been move to a separate package (to be tagged shortly).
  • JIT compilation time has been reduced substantially.
  • Support for silent tag and time limits.

v0.2.1 (July 7, 2019)

  • Bug fix for explicit SIP solving routine that occurred for uncertainty sets of dimension greater than 1.
  • Bug fix for MOI.MAX_SENSE (max objective sense).

v0.2.0 (June 14, 2019)

This update creates a number of breaking changes to the EAGO API. Please review the use cases provided in the documentation to update examples.

  • Updated to support Julia 1.0+, MathOptInterface (MOI), and MOI construction of subproblems.
  • Additional domain reduction routines available.
  • Support for specialized handling of linear and quadratic terms.
  • Significant performance improvements due to pre-allocation of Wengert tapes and MOI support.
  • A more intuitive API for McCormick relaxation construction.

v0.1.2 (June 20, 2018)

  • Significant speed and functionality updates.

v0.1.1 (June 7, 2018)

  • Initial release of combined EAGO packages.

v0.1.0 (April 10, 2018)

  • Main global solver release.
diff --git a/dev/optimizer/bnb_back/index.html b/dev/optimizer/bnb_back/index.html index 575e75ab..a35551a9 100644 --- a/dev/optimizer/bnb_back/index.html +++ b/dev/optimizer/bnb_back/index.html @@ -1,51 +1,51 @@ -EAGO's Branch and Bound Routine · EAGO.jl
GitHub

EAGO's Branch and Bound Routine

This component is meant to provide a flexible framework for implementing spatial branch-and-bound based optimization routines in Julia. All components of the branch-and-bound routine can be customized by the individual user: lower-bounding problem, upper-bounding problem.

Branch and Bound Node Storage

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

The GlobalOptimizer structure holds all information relevant to branch-and-bound.

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

Customizable Subroutines

Stack Management Subroutines

EAGO.branch_node! — Method
branch_node!(t::ExtensionType, m::GlobalOptimizer)
-

Create two nodes from current_node and store them on the stack. Call select_branch_variable(t, m) and select_branch_point(t, m, k) to determine the variable that should be branched on and the point at which branching should occur, respectively.

source
EAGO.select_branch_variable — Method
select_branch_variable(
+EAGO's Branch and Bound Routine · EAGO.jl
GitHub
EAGO's Branch and Bound Routine
This component is meant to provide a flexible framework for implementing spatial branch-and-bound based optimization routines in Julia. All components of the branch-and-bound routine can be customized by the individual user: lower-bounding problem, upper-bounding problem.
Branch and Bound Node Storage
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
The GlobalOptimizer structure holds all information relevant to branch-and-bound.
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
Customizable Subroutines
Stack Management Subroutines
EAGO.branch_node! — Method
branch_node!(t::ExtensionType, m::GlobalOptimizer)
+
Create two nodes from current_node and store them on the stack. Call select_branch_variable(t, m) and select_branch_point(t, m, k) to determine the variable that should be branched on and the point at which branching should occur, respectively.
source
EAGO.select_branch_variable — Method
select_branch_variable(
     t::ExtensionType,
     m::GlobalOptimizer
 ) -> Any
-
Choose a variable to branch on. A maximum relative width branching rule is used by default.
source
EAGO.select_branch_point — Method
select_branch_point(
+
Choose a variable to branch on. A maximum relative width branching rule is used by default.
source
EAGO.select_branch_point — Method
select_branch_point(
     t::ExtensionType,
     m::GlobalOptimizer,
     i
 ) -> Float64
-
Select a point xb within the domain of the ith branching variable. By default, this point is a convex combination of the solution to the relaxation and the midpoint of the node (branch_cvx_factor*xmid + (1-branch_cvx_factor)*xsol). If the solution lies within branch_offset of a bound, then the branch point is moved to a distance of branch_offset from that bound.
source
EAGO.node_selection! — Method
node_selection!(t::ExtensionType, m::GlobalOptimizer)
-
Select the next node in the stack to evaluate. By default, perform best-first  node selection (select the node with the lowest lower bound in the stack).
source
EAGO.fathom! — Method
fathom!(t::ExtensionType, m::GlobalOptimizer)
-
Remove nodes from the stack. By default, delete nodes from the stack if their lower bounds are greater than the current global upper bound.
source
EAGO.initialize_stack! — Method
initialize_stack!(t::ExtensionType, m::GlobalOptimizer)
-
Prepare the stack for the branch-and-bound routine. By default, create an initial node with the variable bounds as box constraints and add it to the stack.
source
EAGO.single_storage! — Method
single_storage!(t::ExtensionType, m::GlobalOptimizer)
-
Store the current node to the stack, without branching, after updating lower/upper bounds.
source
Internal Subproblem Status Codes and Subsolver Management
EAGO.RelaxResultStatus — Type
RelaxResultStatus
Status code used internally to determine how to interpret the results from the solution of a relaxed problem.
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.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.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.set_default_config! — Method
set_default_config!
Configures subsolver tolerances based on tolerance parameters provided to EAGO (provided that a specialized subsolver configuration routine has been provided and m.user_solver_config = false).
source
Main Subproblem and Termination Subroutines
EAGO.convergence_check — Method
convergence_check(
+
Select a point xb within the domain of the ith branching variable. By default, this point is a convex combination of the solution to the relaxation and the midpoint of the node (branch_cvx_factor*xmid + (1-branch_cvx_factor)*xsol). If the solution lies within branch_offset of a bound, then the branch point is moved to a distance of branch_offset from that bound.
source
EAGO.node_selection! — Method
node_selection!(t::ExtensionType, m::GlobalOptimizer)
+
Select the next node in the stack to evaluate. By default, perform best-first  node selection (select the node with the lowest lower bound in the stack).
source
EAGO.fathom! — Method
fathom!(t::ExtensionType, m::GlobalOptimizer)
+
Remove nodes from the stack. By default, delete nodes from the stack if their lower bounds are greater than the current global upper bound.
source
EAGO.initialize_stack! — Method
initialize_stack!(t::ExtensionType, m::GlobalOptimizer)
+
Prepare the stack for the branch-and-bound routine. By default, create an initial node with the variable bounds as box constraints and add it to the stack.
source
EAGO.single_storage! — Method
single_storage!(t::ExtensionType, m::GlobalOptimizer)
+
Store the current node to the stack, without branching, after updating lower/upper bounds.
source
Internal Subproblem Status Codes and Subsolver Management
EAGO.RelaxResultStatus — Type
RelaxResultStatus
Status code used internally to determine how to interpret the results from the solution of a relaxed problem.
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.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.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.set_default_config! — Method
set_default_config!
Configures subsolver tolerances based on tolerance parameters provided to EAGO (provided that a specialized subsolver configuration routine has been provided and m.user_solver_config = false).
source
Main Subproblem and Termination Subroutines
EAGO.convergence_check — Method
convergence_check(
     t::ExtensionType,
     m::GlobalOptimizer
 ) -> Bool
-
Check for problem convergence.
By default, check if the lower and upper bounds have converged to within absolute and/or relative tolerances.
source
EAGO.cut_condition — Method
cut_condition(t::ExtensionType, m::GlobalOptimizer) -> Bool
-
Returns true if a cut should be added and computes a new reference point to add the cut at. By default, checks that cut_max_iterations are not exceeded and that the  improvement in the objective value associated with the previous cut is greater than both an absolute tolerance cut_ϵ_abs and a relative tolerance cut_ϵ_rel. Returns false otherwise.
source
EAGO.lower_problem! — Method
lower_problem!(
+
Check for problem convergence.
By default, check if the lower and upper bounds have converged to within absolute and/or relative tolerances.
source
EAGO.cut_condition — Method
cut_condition(t::ExtensionType, m::GlobalOptimizer) -> Bool
+
Returns true if a cut should be added and computes a new reference point to add the cut at. By default, checks that cut_max_iterations are not exceeded and that the  improvement in the objective value associated with the previous cut is greater than both an absolute tolerance cut_ϵ_abs and a relative tolerance cut_ϵ_rel. Returns false otherwise.
source
EAGO.lower_problem! — Method
lower_problem!(
     t::ExtensionType,
     m::GlobalOptimizer{R, S, Q<:ExtensionType}
 )
-
Constructs a relaxation of the MINLP on node y and solves it using the default EAGO  relaxation scheme. By default, EAGO applies Kelley's algorithm (from Kelley Jr., J.E.:  The cutting-plane method for solving convex programs. J. Soc. Ind. Appl. Math. 8(4),  703 to 712 (1960)) while cut_condition(m) returns true then activates the integrality constraints of the relaxed problems and solves the resulting MILP relaxation. results are stored to the _lower_solution, _lower_termination_status, _lower_primal_status, _lower_dual_status, _lower_objective_value, and _lower_feasibility. Further, lower and upper variable duals are stored _lower_lvd and _lower_uvd, respectively, for use in duality based bound tightening. If relaxation-based bounds are weaker or cutting-planes  are numerically poorly ill-posed, then interval bounds are used instead. If the problem is dual feasible but the primal status is ambiguous the dual objective value is used for the  lower bound to avoid numerical issues.
source
EAGO.preprocess! — Method
preprocess!(
+
Constructs a relaxation of the MINLP on node y and solves it using the default EAGO  relaxation scheme. By default, EAGO applies Kelley's algorithm (from Kelley Jr., J.E.:  The cutting-plane method for solving convex programs. J. Soc. Ind. Appl. Math. 8(4),  703 to 712 (1960)) while cut_condition(m) returns true then activates the integrality constraints of the relaxed problems and solves the resulting MILP relaxation. results are stored to the _lower_solution, _lower_termination_status, _lower_primal_status, _lower_dual_status, _lower_objective_value, and _lower_feasibility. Further, lower and upper variable duals are stored _lower_lvd and _lower_uvd, respectively, for use in duality based bound tightening. If relaxation-based bounds are weaker or cutting-planes  are numerically poorly ill-posed, then interval bounds are used instead. If the problem is dual feasible but the primal status is ambiguous the dual objective value is used for the  lower bound to avoid numerical issues.
source
EAGO.preprocess! — Method
preprocess!(
     t::ExtensionType,
     m::GlobalOptimizer{R, S, Q<:ExtensionType}
 )
-
Runs contractor methods prior to solving lower bounding problem. By default linear and quadratic  contractor methods followed by interval constraint propagation then optimization-based bound  tightening for a specified number of iterations while the subproblem at current node n has  not been proven infeasible.
source
EAGO.postprocess! — Method
postprocess!(t::ExtensionType, m::GlobalOptimizer)
-
Default postprocess perfoms duality-based bound tightening (Tawarmalani, M.,  Sahinidis, N.V.: Global optimization of mixed-integer nonlinear programs:  a theoretical and computational study. Math. Progr. 99, 563–591 (2004).) up to an iteration limit set by dbbt_depth.
source
EAGO.repeat_check — Method
repeat_check(t::ExtensionType, m::GlobalOptimizer) -> Bool
-
Check to see if current node should be reprocessed. Without any custom extension, return false by default.
source
EAGO.termination_check — Method
termination_check(m::GlobalOptimizer)
-termination_check(t::ExtensionType, m::GlobalOptimizer) -> Bool
Check for termination of the branch-and-bound algorithm.
If only the GlobalOptimizer is given as an argument, termination_check dispatches to the other form using the ExtensionType given in the SubSolvers. If there is no user-defined extension, then by default, this will check for satisfaction of absolute or relative tolerances, solution infeasibility, and other specified limits. Returns  true if any conditions are met and branch-and-bound should end, and false otherwise.
source
EAGO.upper_problem! — Method
upper_problem!(t::ExtensionType, m::GlobalOptimizer)
-
Default upper bounding problem which simply calls solve_local_nlp! to solve the NLP locally.
source
EAGO.parse_global! — Method
Basic parsing for global solutions (no extensive manipulation). By default, does nothing.
source
EAGO.optimize_hook! — Method
optimize_hook!(t::ExtensionType, m::Optimizer)
Provide a hook for extensions to EAGO. 
The user-defined extension of optimize_hook! is used in EAGO's overloading of MOI.optimize! (see EAGO.jl/src/eago_optimizer/optimize/optimize.jl). Without the optimize_hook! specified, EAGO will run initial_parse!, parse_classify_problem!, and then optimize! using the parsed problem type. The user-specified optimize_hook!  should thus take the new extension and Optimizer as inputs and will execute when the  user writes optimize!(model).
Example
Here, optimize_hook! is used to bypass EAGO's problem parsing and treat every problem using its branch-and-bound routine. This is done in this example by telling EAGO to treat the problem as a mixed integer nonconvex problem, which normally dispatches to branch-and-bound.
struct MyNewExtension <: EAGO.ExtensionType end
+
Runs contractor methods prior to solving lower bounding problem. By default linear and quadratic  contractor methods followed by interval constraint propagation then optimization-based bound  tightening for a specified number of iterations while the subproblem at current node n has  not been proven infeasible.
source
EAGO.postprocess! — Method
postprocess!(t::ExtensionType, m::GlobalOptimizer)
+
Default postprocess perfoms duality-based bound tightening (Tawarmalani, M.,  Sahinidis, N.V.: Global optimization of mixed-integer nonlinear programs:  a theoretical and computational study. Math. Progr. 99, 563–591 (2004).) up to an iteration limit set by dbbt_depth.
source
EAGO.repeat_check — Method
repeat_check(t::ExtensionType, m::GlobalOptimizer) -> Bool
+
Check to see if current node should be reprocessed. Without any custom extension, return false by default.
source
EAGO.termination_check — Method
termination_check(m::GlobalOptimizer)
+termination_check(t::ExtensionType, m::GlobalOptimizer) -> Bool
Check for termination of the branch-and-bound algorithm.
If only the GlobalOptimizer is given as an argument, termination_check dispatches to the other form using the ExtensionType given in the SubSolvers. If there is no user-defined extension, then by default, this will check for satisfaction of absolute or relative tolerances, solution infeasibility, and other specified limits. Returns  true if any conditions are met and branch-and-bound should end, and false otherwise.
source
EAGO.upper_problem! — Method
upper_problem!(t::ExtensionType, m::GlobalOptimizer)
+
Default upper bounding problem which simply calls solve_local_nlp! to solve the NLP locally.
source
EAGO.parse_global! — Method
Basic parsing for global solutions (no extensive manipulation). By default, does nothing.
source
EAGO.optimize_hook! — Method
optimize_hook!(t::ExtensionType, m::Optimizer)
Provide a hook for extensions to EAGO. 
The user-defined extension of optimize_hook! is used in EAGO's overloading of MOI.optimize! (see EAGO.jl/src/eago_optimizer/optimize/optimize.jl). Without the optimize_hook! specified, EAGO will run initial_parse!, parse_classify_problem!, and then optimize! using the parsed problem type. The user-specified optimize_hook!  should thus take the new extension and Optimizer as inputs and will execute when the  user writes optimize!(model).
Example
Here, optimize_hook! is used to bypass EAGO's problem parsing and treat every problem using its branch-and-bound routine. This is done in this example by telling EAGO to treat the problem as a mixed integer nonconvex problem, which normally dispatches to branch-and-bound.
struct MyNewExtension <: EAGO.ExtensionType end
 import EAGO: optimize_hook!
 function EAGO.optimize_hook!(t::MyNewExtension, m::Optimizer)
     initial_parse!(m)
     optimize!(EAGO.MINCVX(), m)
-end
The same functionality could be accomplished by setting the EAGOParameter field force_global_solve to be true.
source
Internal Subroutines
EAGO.is_integer_subproblem — Method
is_integer_subproblem(m)
-
Returns true that the subproblem at the current node n has participating integer variables that have not been fixed to constant valued as the branch-and-bound algorithm progresses. Returns false otherwise.
source
EAGO.is_integer_feasible_local — Method
is_integer_feasible_local(m::GlobalOptimizer, d) -> Bool
-
Checks that the solution of a local solve is integer feasible to within the tolerances specified by integer_abs_tol and integer_rel_tol.
source
EAGO.is_integer_feasible_relaxed — Method
is_integer_feasible_relaxed(m::GlobalOptimizer) -> Bool
-
Check that the solution of the lower (relaxed problem) is integer feasible to within tolerances specified by the parameters: integer_abs_tol (absolute tolerance) and integer_rel_tol (relative tolerance).
source
EAGO.interval_bound — Function
interval_bound(::GlobalOptimizer, ::T)
Compute a tuple representing the lower and upper interval bounds for an AbstractEAGOConstraint representing an equality constraint.
Options for T (all are subtypes of AbstractEAGOConstraint):
  • AffineFunctionEq
  • AffineFunctionIneq
  • BufferedQuadraticEq
  • BufferedQuadraticIneq
  • BufferedNonlinearFunction{V,N,T} where {V,N,T}
source
EAGO.lower_interval_bound — Function
lower_interval_bound(::GlobalOptimizer, ::T)
Compute the lower interval bound for an AbstractEAGOConstraint representing an inequality constraint.
Options for T (all are subtypes of AbstractEAGOConstraint):
  • AffineFunctionIneq
  • BufferedQuadraticIneq
  • BufferedSOC
  • BufferedNonlinearFunction{V,N,T} where {V,N,T}
source
EAGO.same_box — Method
same_box(x::NodeBB, y::NodeBB, r::Float64) -> Bool
-
Check that node x and y have equal domains within an absolute tolerance of r.
source
EAGO.solve_local_nlp! — Method
Constructs and solves the problem locally on node y updated the upper solution informaton in the optimizer.
source
EAGO.set_dual! — Method
set_dual!(m)
-
Retrieves the lower and upper duals for variable bounds from the relaxed_optimizer and sets the appropriate values in the _lower_lvd and _lower_uvd storage fields.
source
EAGO.update_relaxed_problem_box! — Function
update_relaxed_problem_box!(m)
-
Update the relaxed constraint by setting the constraint set of v == x* , xL_i <= x_i, and x_i <= xU_i for each such constraint added to the relaxed optimizer. Resets integral valued constraints to either EqualTo or Interval  constraints.
source
EAGO.reform_epigraph_min! — Method
reform_epigraph_min!(m::GlobalOptimizer)
-
Perform an epigraph reformulation assuming the working_problem is a minimization problem.
source
EAGO.label_fixed_variables! — Method
label_fixed_variables!(m::GlobalOptimizer) -> Vector{Bool}
-
Detect any variables set to a fixed value by equality or inequality constraints and populate the _fixed_variable storage array.
source
EAGO.label_branch_variables! — Method
label_branch_variables!(m::GlobalOptimizer)
-
Detect any variables participating in nonconvex terms and populate the _branch_variables storage array.
source
EAGO.add_nonlinear! — Method
add_nonlinear!(m::GlobalOptimizer)
-
Add an Evaluator and nonlinear functions and populate each appropriately.
source
EAGO.parse_classify_problem! — Method
parse_classify_problem!(m::GlobalOptimizer)
Interprets the type/number of constraints and the type of objective function to infer a problem type. Current possible types include:
  • LP: Linear program; sent to optimize_lp.jl
  • 'MILP: Mixed integer linear program; sent tooptimize_lp.jl`
  • SOCP: Second-order cone program; sent to optimize_conic.jl
  • MINCVX: Mixed-integer nonconvex; sent to optimize_nonconvex.jl
If the force_global_solve parameter is set to true, parse_classify_problem! will set the problem type to MINCVX to pass the problem to optimize_nonconvex.jl.
source
EAGO.local_problem_status — Method
local_problem_status(t, r)
-
Takes an MOI.TerminationStatusCode and a MOI.ResultStatusCode and returns true if this corresponds to a solution that is proven to be feasible. Returns false otherwise.
source
Functions for Generating Console Output
EAGO.print_iteration! — Function
print_iteration!
Print status information based on iteration count. The header print frequency is based on the header_iterations setting, and the data print frequency is based on the output_iterations setting.
source
EAGO.print_node! — Function
print_node!
Print information about the current node. Includes node ID, lower bound, upper bound, and interval box.
source
EAGO.print_results! — Function
print_results!(m::GlobalOptimizer, lower_flag::Bool)
-
Print the results of a single (lower or upper) bounding problem. lower_flag=true prints information for the lower problem, lower_flag=false prints information for the upper problem.
source
EAGO.print_solution! — Function
print_solution!
Print solution information for the B&B problem. Display node with the best solution, solution value, solution, and time spent solving subproblems. This print occurs following termination of the B&B algorithm.
source
Support for Log Output at Each Iteration
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.log_iteration! — Method
log_iteration!(m::GlobalOptimizer)
-
If log_on is true, the global_lower_bound, global_upper_bound, run_time, and node_count are stored every log_interval. If log_subproblem_info then the lower bound, feasibility and run times of the subproblems are logged every log_interval.
source
Interval Representations of Expressions
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.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.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.NonlinearExpression — Type
mutable struct NonlinearExpression{V, N, T<:RelaxTag} <: EAGO.AbstractEAGOConstraint
Stores a general quadratic function with a buffer.
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

+end

The same functionality could be accomplished by setting the EAGOParameter field force_global_solve to be true.

source

Internal Subroutines

EAGO.is_integer_subproblem — Method
is_integer_subproblem(m)
+

Returns true that the subproblem at the current node n has participating integer variables that have not been fixed to constant valued as the branch-and-bound algorithm progresses. Returns false otherwise.

source
EAGO.is_integer_feasible_local — Method
is_integer_feasible_local(m::GlobalOptimizer, d) -> Bool
+

Checks that the solution of a local solve is integer feasible to within the tolerances specified by integer_abs_tol and integer_rel_tol.

source
EAGO.is_integer_feasible_relaxed — Method
is_integer_feasible_relaxed(m::GlobalOptimizer) -> Bool
+

Check that the solution of the lower (relaxed problem) is integer feasible to within tolerances specified by the parameters: integer_abs_tol (absolute tolerance) and integer_rel_tol (relative tolerance).

source
EAGO.interval_bound — Function
interval_bound(::GlobalOptimizer, ::T)

Compute a tuple representing the lower and upper interval bounds for an AbstractEAGOConstraint representing an equality constraint.

Options for T (all are subtypes of AbstractEAGOConstraint):

  • AffineFunctionEq
  • AffineFunctionIneq
  • BufferedQuadraticEq
  • BufferedQuadraticIneq
  • BufferedNonlinearFunction{V,N,T} where {V,N,T}
source
EAGO.lower_interval_bound — Function
lower_interval_bound(::GlobalOptimizer, ::T)

Compute the lower interval bound for an AbstractEAGOConstraint representing an inequality constraint.

Options for T (all are subtypes of AbstractEAGOConstraint):

  • AffineFunctionIneq
  • BufferedQuadraticIneq
  • BufferedSOC
  • BufferedNonlinearFunction{V,N,T} where {V,N,T}
source
EAGO.same_box — Method
same_box(x::NodeBB, y::NodeBB, r::Float64) -> Bool
+

Check that node x and y have equal domains within an absolute tolerance of r.

source
EAGO.solve_local_nlp! — Method

Constructs and solves the problem locally on node y updated the upper solution informaton in the optimizer.

source
EAGO.set_dual! — Method
set_dual!(m)
+

Retrieves the lower and upper duals for variable bounds from the relaxed_optimizer and sets the appropriate values in the _lower_lvd and _lower_uvd storage fields.

source
EAGO.update_relaxed_problem_box! — Function
update_relaxed_problem_box!(m)
+

Update the relaxed constraint by setting the constraint set of v == x* , xL_i <= x_i, and x_i <= xU_i for each such constraint added to the relaxed optimizer. Resets integral valued constraints to either EqualTo or Interval constraints.

source
EAGO.reform_epigraph_min! — Method
reform_epigraph_min!(m::GlobalOptimizer)
+

Perform an epigraph reformulation assuming the working_problem is a minimization problem.

source
EAGO.label_fixed_variables! — Method
label_fixed_variables!(m::GlobalOptimizer) -> Vector{Bool}
+

Detect any variables set to a fixed value by equality or inequality constraints and populate the _fixed_variable storage array.

source
EAGO.label_branch_variables! — Method
label_branch_variables!(m::GlobalOptimizer)
+

Detect any variables participating in nonconvex terms and populate the _branch_variables storage array.

source
EAGO.add_nonlinear! — Method
add_nonlinear!(m::GlobalOptimizer)
+

Add an Evaluator and nonlinear functions and populate each appropriately.

source
EAGO.parse_classify_problem! — Method
parse_classify_problem!(m::GlobalOptimizer)

Interprets the type/number of constraints and the type of objective function to infer a problem type. Current possible types include:

  • LP: Linear program; sent to optimize_lp.jl
  • 'MILP: Mixed integer linear program; sent tooptimize_lp.jl`
  • SOCP: Second-order cone program; sent to optimize_conic.jl
  • MINCVX: Mixed-integer nonconvex; sent to optimize_nonconvex.jl

If the force_global_solve parameter is set to true, parse_classify_problem! will set the problem type to MINCVX to pass the problem to optimize_nonconvex.jl.

source
EAGO.local_problem_status — Method
local_problem_status(t, r)
+

Takes an MOI.TerminationStatusCode and a MOI.ResultStatusCode and returns true if this corresponds to a solution that is proven to be feasible. Returns false otherwise.

source

Functions for Generating Console Output

EAGO.print_iteration! — Function

print_iteration!

Print status information based on iteration count. The header print frequency is based on the header_iterations setting, and the data print frequency is based on the output_iterations setting.

source
EAGO.print_node! — Function

print_node!

Print information about the current node. Includes node ID, lower bound, upper bound, and interval box.

source
EAGO.print_results! — Function
print_results!(m::GlobalOptimizer, lower_flag::Bool)
+

Print the results of a single (lower or upper) bounding problem. lower_flag=true prints information for the lower problem, lower_flag=false prints information for the upper problem.

source
EAGO.print_solution! — Function

print_solution!

Print solution information for the B&B problem. Display node with the best solution, solution value, solution, and time spent solving subproblems. This print occurs following termination of the B&B algorithm.

source

Support for Log Output at Each Iteration

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.log_iteration! — Method
log_iteration!(m::GlobalOptimizer)
+

If log_on is true, the global_lower_bound, global_upper_bound, run_time, and node_count are stored every log_interval. If log_subproblem_info then the lower bound, feasibility and run times of the subproblems are logged every log_interval.

source

Interval Representations of Expressions

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.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.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.NonlinearExpression — Type
mutable struct NonlinearExpression{V, N, T<:RelaxTag} <: EAGO.AbstractEAGOConstraint

Stores a general quadratic function with a buffer.

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
diff --git a/dev/optimizer/domain_reduction/index.html b/dev/optimizer/domain_reduction/index.html index e1f58e76..ed3a2542 100644 --- a/dev/optimizer/domain_reduction/index.html +++ b/dev/optimizer/domain_reduction/index.html @@ -7,21 +7,21 @@ UBD::Float64, nx::Int64 ) -

Tighten the bounds of the _current_node using the current global upper bound and the duality information obtained from the relaxation.

source

Special Forms

Bound tightening for linear forms, univariate quadratic forms, and bivariate quadratic forms are also supported.

EAGO.fbbt! — Function
fbbt!(m::GlobalOptimizer, f::T)

Performs feasibility-based bound tightening on a back-end constraint and returns true if it is feasible or false if it is infeasible.

Options for T (all are subtypes of AbstractEAGOConstraint):

  • AffineFunctionIneq
  • AffineFunctionEq
source

Constraint Propagation

EAGO contains a constraint propagation architecture that supported forward and reverse evaluation of set-valued functions on the directed acyclic graph. The interval contractor and reverse McCormick relaxation-based contractors are currently available.

EAGO.set_constraint_propagation_fbbt! — Function
set_constraint_propagation_fbbt!(
+

Tighten the bounds of the _current_node using the current global upper bound and the duality information obtained from the relaxation.

source

Special Forms

Bound tightening for linear forms, univariate quadratic forms, and bivariate quadratic forms are also supported.

EAGO.fbbt! — Function
fbbt!(m::GlobalOptimizer, f::T)

Performs feasibility-based bound tightening on a back-end constraint and returns true if it is feasible or false if it is infeasible.

Options for T (all are subtypes of AbstractEAGOConstraint):

  • AffineFunctionIneq
  • AffineFunctionEq
source

Constraint Propagation

EAGO contains a constraint propagation architecture that supported forward and reverse evaluation of set-valued functions on the directed acyclic graph. The interval contractor and reverse McCormick relaxation-based contractors are currently available.

EAGO.set_constraint_propagation_fbbt! — Function
set_constraint_propagation_fbbt!(
     m::GlobalOptimizer{R, S, Q<:ExtensionType}
 ) -> Bool
-

Performs bound tightening based on forward/reverse interval and/or McCormick passes. This routine resets the current node with new interval bounds.

source

Optimization-Based Bound Tightening

EAGO makes use of an optimization-based bound tightening scheme using filtering and greedy ordering as detailed in [1].

EAGO.obbt! — Function
obbt!(m::GlobalOptimizer{R, S, Q<:ExtensionType}) -> Bool
-

Performs OBBT with filtering and greedy ordering as detailed in: Gleixner, A.M., Berthold, T., Müller, B. et al. J Glob Optim (2017) 67: 731. https://doi.org/10.1007/s10898-016-0450-4

source
EAGO.trivial_filtering! — Method
trivial_filtering!(
+

Performs bound tightening based on forward/reverse interval and/or McCormick passes. This routine resets the current node with new interval bounds.

source

Optimization-Based Bound Tightening

EAGO makes use of an optimization-based bound tightening scheme using filtering and greedy ordering as detailed in [1].

EAGO.obbt! — Function
obbt!(m::GlobalOptimizer{R, S, Q<:ExtensionType}) -> Bool
+

Performs OBBT with filtering and greedy ordering as detailed in: Gleixner, A.M., Berthold, T., Müller, B. et al. J Glob Optim (2017) 67: 731. https://doi.org/10.1007/s10898-016-0450-4

source
EAGO.trivial_filtering! — Method
trivial_filtering!(
     m::GlobalOptimizer{R, S, Q<:ExtensionType},
     n::NodeBB
 )
-

Excludes OBBT on variable indices that are tight for the solution of the relaxation.

source
EAGO.aggressive_filtering! — Method
aggressive_filtering!(
+

Excludes OBBT on variable indices that are tight for the solution of the relaxation.

source
EAGO.aggressive_filtering! — Method
aggressive_filtering!(
     m::GlobalOptimizer{R, S, Q<:ExtensionType},
     n::NodeBB
 ) -> Bool
-

Excludes OBBT on variable indices after a search in a filtering direction.

source
EAGO.bool_indx_diff! — Method
bool_indx_diff!(
+

Excludes OBBT on variable indices after a search in a filtering direction.

source
EAGO.bool_indx_diff! — Method
bool_indx_diff!(
     z::Vector{Bool},
     x::Vector{Bool},
     y::Vector{Bool}
 ) -> Vector{Bool}
-

Utility function used to set vector of booleans z to x & ~y. Avoids the generation of conversion of the BitArray created by broadcasting logical operators.

source

References

  1. Gleixner, A.M., Berthold, T., Müller, B. et al. J Glob Optim (2017) 67: 731. https://doi.org/10.1007/s10898-016-0450-4
+

Utility function used to set vector of booleans z to x & ~y. Avoids the generation of conversion of the BitArray created by broadcasting logical operators.

source

References

  1. Gleixner, A.M., Berthold, T., Müller, B. et al. J Glob Optim (2017) 67: 731. https://doi.org/10.1007/s10898-016-0450-4
diff --git a/dev/optimizer/high_performance/index.html b/dev/optimizer/high_performance/index.html index 68b64225..a05dea11 100644 --- a/dev/optimizer/high_performance/index.html +++ b/dev/optimizer/high_performance/index.html @@ -3,4 +3,4 @@ eago_factory = () -> EAGO.Optimizer(SubSolvers(; r = Gurobi.Optimizer())) m = Model(eago_factory)

Rounding Mode

The IntervalArithmetic.jl package supports a number of different directed rounding modes. The default directed rounding mode is :tight. It is recommended that the user specify that :accurate directed rounding mode be used as it may results in a significant performance improvement. Setting a rounding mode can requires the redefinition of a number of functions. As a result, this should only be done at the top-level by the user (rather than by using keyword arguments). To set the rounding mode to :accurate using the following syntax when loading the EAGO package initially:

using IntervalArithmetic; setrounding(Interval, :accurate)
 using EAGO
-# REST OF CODE

Ipopt Build

Ipopt is the recommended solver for upper-bounding problems. Ipopt's performance is highly dependent on the linear algebra package used (up to 30x). By default MUMPS is used. It is recommended that you either compile Ipopt with HSL MA57 or the Pardiso linear algebra packages with a machine specific Blas library (for Intel users the JuliaPro MKL version is recommended). For information on this, see the links below:

+# REST OF CODE

Ipopt Build

Ipopt is the recommended solver for upper-bounding problems. Ipopt's performance is highly dependent on the linear algebra package used (up to 30x). By default MUMPS is used. It is recommended that you either compile Ipopt with HSL MA57 or the Pardiso linear algebra packages with a machine specific Blas library (for Intel users the JuliaPro MKL version is recommended). For information on this, see the links below:

diff --git a/dev/optimizer/optimizer/index.html b/dev/optimizer/optimizer/index.html index 0eda3a4c..f70b9ddb 100644 --- a/dev/optimizer/optimizer/index.html +++ b/dev/optimizer/optimizer/index.html @@ -1,3 +1,3 @@ -EAGO Optimizer · EAGO.jl
GitHub

EAGO Optimizer

The Optimizer object holds all algorithm solution information. A description of all user-facing options has been provided in the docstring.

EAGO.Optimizer

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 Specific Functions and Operators

EAGO supports a number of functions and operators that for which specialized relaxation routines are available. These can be registered and added to a JuMP model using the function:

EAGO.register_eago_operators! — Method

registereagooperators!

Registers all nonstandard nonlinear terms available in EAGO in a JuMP. Uses of these is generally preferable in EAGO as the relaxations EAGO will generate will usually be tighter (speeding up convergence time). Note that this will work can be used by other nonlinear solvers (Ipopt for instance).

source

Storage for Input Parameters

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

Internal Storage Structures

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

Internal Problem Representations

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

Interval Optimizer Subroutines

EAGO.initial_parse! — Method
initial_parse!(m::Optimizer{R, S, T})
-

Translate the input problem to the working problem. Any checks or optional manipulation are left to the presolve stage.

source

Extending EAGO

Functionality has been included that allows for extensions to EAGO's Optimizer to be readily defined. This can be done in two ways first defining a new structure which is a subtype of ExtensionType and overloading methods associated with this new structure. An instance of this new structure is provided to the Optimizer using the ext_type keyword. This results in EAGO now dispatch to the new methods rather than the generally defined methods for the parent type. For a complete example, the reader is directed to the interval bounding example and the quasiconvex example. Alternatively, the user can overload the optimize_hook! for this subtype which will entirely circumvent the default global solution routine. Additional information can be stored in the ext field of the Optimizer. In order to allow for compatibility between packages the user is encouraged to append their extension name to the start of each variable name (e.g. newext_newdata).

+EAGO Optimizer · EAGO.jl
GitHub

EAGO Optimizer

The Optimizer object holds all algorithm solution information. A description of all user-facing options has been provided in the docstring.

EAGO.Optimizer

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 Specific Functions and Operators

EAGO supports a number of functions and operators that for which specialized relaxation routines are available. These can be registered and added to a JuMP model using the function:

EAGO.register_eago_operators! — Method

registereagooperators!

Registers all nonstandard nonlinear terms available in EAGO in a JuMP. Uses of these is generally preferable in EAGO as the relaxations EAGO will generate will usually be tighter (speeding up convergence time). Note that this will work can be used by other nonlinear solvers (Ipopt for instance).

source

Storage for Input Parameters

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

Internal Storage Structures

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

Internal Problem Representations

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

Interval Optimizer Subroutines

EAGO.initial_parse! — Method
initial_parse!(m::Optimizer{R, S, T})
+

Translate the input problem to the working problem. Any checks or optional manipulation are left to the presolve stage.

source

Extending EAGO

Functionality has been included that allows for extensions to EAGO's Optimizer to be readily defined. This can be done in two ways first defining a new structure which is a subtype of ExtensionType and overloading methods associated with this new structure. An instance of this new structure is provided to the Optimizer using the ext_type keyword. This results in EAGO now dispatch to the new methods rather than the generally defined methods for the parent type. For a complete example, the reader is directed to the interval bounding example and the quasiconvex example. Alternatively, the user can overload the optimize_hook! for this subtype which will entirely circumvent the default global solution routine. Additional information can be stored in the ext field of the Optimizer. In order to allow for compatibility between packages the user is encouraged to append their extension name to the start of each variable name (e.g. newext_newdata).

diff --git a/dev/optimizer/relax_back/index.html b/dev/optimizer/relax_back/index.html index c94d6ab1..636303be 100644 --- a/dev/optimizer/relax_back/index.html +++ b/dev/optimizer/relax_back/index.html @@ -1,7 +1,7 @@ -Nonlinear Backend · EAGO.jl
GitHub

Nonlinear Backend

Graphs, Caches, Forward and Reverse Propagation

EAGO makes use of a specialized tape structure for each function in order to compute valid composite bounds and relaxations. Each variable, constant, and expression is represented by a node in a directed graph structure.

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

Describes connectivity and expression represented by node.

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

Each field of the ith EAGO.Node using a basic access function. For instance the ith node's ex_type for graph d may be accessed by ex_type(d, i). The sparsity of node i returns an ordered list of children nodes which form the argument tuple for the operator performed at node i. The sparsity of node i returns a list of parent nodes which form the argument tuple for the operator performed at node i. The parameter_values and constant_values functions are used to access the ith parameter values or ith constant values.

EAGO organizes information associated with each node in a given graph structure using an EAGO.AbstractCache which stores the given information.

EAGO.AbstractCache — Type
abstract type AbstractCache

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

source
EAGO.initialize! — Method
initialize!(_::AbstractCache, _::AbstractDirectedGraph)
-

Function used to initialize the storage cache d::AbstractCache for a given type of directed acyclic graph g::AbstractDirectedGraph.

source

Information in a given EAGO.AbstractCache is populated by performing a series of forward and reverse passes of the graph structure which dispatch off of an EAGO.AbstractCacheAttribute which indicates what particular information is desired.

Three included AbstractCacheAttributes are used to

The forward and reverse routines are overloaded as follows:

EAGO.f_init! — Method

Initializes information in cache c for each node in g that may be used in a forward-pass of attribute t.

source
EAGO.fprop! — Method

Populates information associated with attribute t for a variable v at index k in cache c associated with graph g using information at index k.

source
EAGO.fprop! — Method

Populates information associated with attribute t for a subexpression v at index k in cache c associated with graph g using information taken from the children of k.

source
EAGO.fprop! — Method

Populates information associated with attribute t for a expression v at index k in cache c associated with graph g using information taken from the children of k.

source
EAGO.fprop! — Method

Populates information associated with attribute t for a parameter v at index k in cache c associated with graph g using information at index k.

source
EAGO.fprop! — Method

Populates information associated with attribute t for a constant v at index k in cache c associated with graph g using information at index k.

source
EAGO.r_init! — Method

Initializes information in cache c for each node in g that may be used in a reverse-pass of attribute t.

source
EAGO.rprop! — Method

Populates information associated with attribute t for a variable v at index k in cache c associated with graph g using information at index k taken from the parents of k.

source
EAGO.rprop! — Method

Populates information associated with attribute t for a subexpressions v at index k in cache c associated with graph g using information at index k taken from the parents of k.

source
EAGO.rprop! — Method

Populates information associated with attribute t for a expressions v at index k in cache c associated with graph g using information at index k taken from the parents of k.

source
EAGO.rprop! — Method

Populates information associated with attribute t for a parameters v at index k in cache c associated with graph g using information at index k taken from the parents of k.

source
EAGO.rprop! — Method

Populates information associated with attribute t for a constant v at index k in cache c associated with graph g using information at index k taken from the parents of k.

source

Forward and reverse subroutines are overloaded for individual operators using through functions of the forms fprop!(t::AbstractCacheAttribute, v::Val{AtomType}, g::AbstractDirectedGraph, b::AbstractCache, k::Int) and rprop!(t::AbstractCacheAttribute, v::Val{AtomType}, g::AbstractDirectedGraph, b::AbstractCache, k::Int).

Other Routines

EAGO.is_safe_cut! — Method
is_safe_cut!(
+Nonlinear Backend · EAGO.jl
GitHub
Nonlinear Backend
Graphs, Caches, Forward and Reverse Propagation
EAGO makes use of a specialized tape structure for each function in order to compute valid composite bounds and relaxations. Each variable, constant, and expression is represented by a node in a directed graph structure. 
EAGO.Node — Type
struct Node <: EAGO.AbstractNode
Describes connectivity and expression represented by node.
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
Each field of the ith EAGO.Node using a basic access function. For instance the ith node's ex_type for graph d may be accessed by ex_type(d, i). The sparsity of node i returns an ordered list of children nodes which form the argument tuple for the operator performed at node i. The sparsity of node i returns a list of parent nodes which form the argument tuple for the operator performed at node i. The parameter_values and constant_values functions are used to access the ith parameter values or ith constant values.
EAGO organizes information associated with each node in a given graph structure using an EAGO.AbstractCache which stores the given information.
EAGO.AbstractCache — Type
abstract type AbstractCache
Abstract supertype used for information storage object the directed acyclic graph.
source
EAGO.initialize! — Method
initialize!(_::AbstractCache, _::AbstractDirectedGraph)
+
Function used to initialize the storage cache d::AbstractCache  for a given type of directed acyclic graph g::AbstractDirectedGraph.
source
Information in a given EAGO.AbstractCache is populated by performing a series of forward and reverse passes of the graph structure which dispatch off of an EAGO.AbstractCacheAttribute which indicates what particular information is desired.
Three included AbstractCacheAttributes are used to 
The forward and reverse routines are overloaded as follows:
EAGO.f_init! — Method
Initializes information in cache c for each node in g that may be used in a forward-pass of attribute t. 
source
EAGO.fprop! — Method
Populates information associated with attribute t for a variable v at index k in  cache c associated with graph g using information at index k. 
source
EAGO.fprop! — Method
Populates information associated with attribute t for a subexpression v at index k in  cache c associated with graph g using information taken from the children of k. 
source
EAGO.fprop! — Method
Populates information associated with attribute t for a expression v at index k in  cache c associated with graph g using information taken from the children of k. 
source
EAGO.fprop! — Method
Populates information associated with attribute t for a parameter v at index k in  cache c associated with graph g using information at index k. 
source
EAGO.fprop! — Method
Populates information associated with attribute t for a constant v at index k in  cache c associated with graph g using information at index k. 
source
EAGO.r_init! — Method
Initializes information in cache c for each node in g that may be used in a reverse-pass of attribute t. 
source
EAGO.rprop! — Method
Populates information associated with attribute t for a variable v at index k in  cache c  associated with graph g using information at index k taken from the parents of k. 
source
EAGO.rprop! — Method
Populates information associated with attribute t for a subexpressions v at index k in  cache c  associated with graph g using information at index k taken from the parents of k. 
source
EAGO.rprop! — Method
Populates information associated with attribute t for a expressions v at index k in  cache c  associated with graph g using information at index k taken from the parents of k. 
source
EAGO.rprop! — Method
Populates information associated with attribute t for a parameters v at index k in  cache c  associated with graph g using information at index k taken from the parents of k. 
source
EAGO.rprop! — Method
Populates information associated with attribute t for a constant v at index k in  cache c  associated with graph g using information at index k taken from the parents of k.
source
Forward and reverse subroutines are overloaded for individual operators using through functions of the forms  fprop!(t::AbstractCacheAttribute, v::Val{AtomType}, g::AbstractDirectedGraph, b::AbstractCache, k::Int) and rprop!(t::AbstractCacheAttribute, v::Val{AtomType}, g::AbstractDirectedGraph, b::AbstractCache, k::Int). 
Other Routines
EAGO.is_safe_cut! — Method
is_safe_cut!(
     m::GlobalOptimizer,
     f::MathOptInterface.ScalarAffineFunction{Float64}
 ) -> Bool
-
Applies the safe cut checks detailed in Khajavirad, 2018 [Khajavirad, Aida, and Nikolaos V. Sahinidis. "A hybrid LP/NLP paradigm for global optimization relaxations." Mathematical Programming Computation 10.3 (2018): 383-421] to ensure that only numerically safe affine relaxations are added. Checks that:
  1. |b| <= safe b, 
  2. safe_l <= abs(ai) <= safe u, and 
  3. safe_l <= abs(ai/aj) <= safe_u.
source

+

Applies the safe cut checks detailed in Khajavirad, 2018 [Khajavirad, Aida, and Nikolaos V. Sahinidis. "A hybrid LP/NLP paradigm for global optimization relaxations." Mathematical Programming Computation 10.3 (2018): 383-421] to ensure that only numerically safe affine relaxations are added. Checks that:

  1. |b| <= safe b,
  2. safe_l <= abs(ai) <= safe u, and
  3. safe_l <= abs(ai/aj) <= safe_u.
source
diff --git a/dev/optimizer/udf_utilities/index.html b/dev/optimizer/udf_utilities/index.html index 2977bf79..9793f075 100644 --- a/dev/optimizer/udf_utilities/index.html +++ b/dev/optimizer/udf_utilities/index.html @@ -1,2 +1,2 @@ -User-Defined Functions and Directed Acyclic Graph Utilities · EAGO.jl
GitHub

User-Defined Functions and Directed Acyclic Graph Utilities

EAGO has included basic functionality to manipulate user-defined functions (UDFs). EAGO also has utilities for directed acyclic graphs (DAGs). These features are largely experimental and we're interested in providing additional features for novel use cases.

DAG Substitution and Flattening

EAGO.Script.dag_flattening! — Function
dag_flattening!

Flattens (usually) the dag by making all registered substitutions for every nonlinear term in the Optimizer.

source
EAGO.Script.flatten_expression! — Function
flatten_expression!

Flattens (usually) the dag by making all registered substitutions for the expression expr::MOINL.Expression. Performs a depth-first search through the expression adding the terminal node to the stack, then checking to determine if it matches a registered substitution pattern. If it doesn't not then node is added to the new expression graph representation and it's children are added to the queue. If an expression (node) is identified as a pattern then it is substituted and any children expression nodes are then checked for patterns until the depth first search is exhausted.

source
EAGO.Script.register_substitution! — Function
register_substitution!

Specifies that the src::Template_Graph should be subsituted out for the trg::Template_Graph.

Conventions for substition, the expression to be checked always appears at key 1 in the Template_Graph and operations are ordered from low value to high value left to right so if 1 is a -, and 4 => 1, 3 => 1 then the expression is 4 - 3

source
EAGO.Script.Template_Graph — Type
Template_Graph

Holds a list of Template_Nodes, set of directed edges, lengths, an adjacency matrix and the number of children.

source
EAGO.Script.Template_Node — Type
Template_Node

A structure which holds a symbol indicating whether the node is an operator, a number, or an expression type, a value which identifies the function or symbol value, potentially a numeric value num_value, and a check that can be run to verify the node is correct check.

source

UDF Scrubber

Missing docstring.

Missing docstring for scrub. Check Documenter's build log for details.

Missing docstring.

Missing docstring for scrub!. Check Documenter's build log for details.

+User-Defined Functions and Directed Acyclic Graph Utilities · EAGO.jl
GitHub

User-Defined Functions and Directed Acyclic Graph Utilities

EAGO has included basic functionality to manipulate user-defined functions (UDFs). EAGO also has utilities for directed acyclic graphs (DAGs). These features are largely experimental and we're interested in providing additional features for novel use cases.

DAG Substitution and Flattening

EAGO.Script.dag_flattening! — Function
dag_flattening!

Flattens (usually) the dag by making all registered substitutions for every nonlinear term in the Optimizer.

source
EAGO.Script.flatten_expression! — Function
flatten_expression!

Flattens (usually) the dag by making all registered substitutions for the expression expr::MOINL.Expression. Performs a depth-first search through the expression adding the terminal node to the stack, then checking to determine if it matches a registered substitution pattern. If it doesn't not then node is added to the new expression graph representation and it's children are added to the queue. If an expression (node) is identified as a pattern then it is substituted and any children expression nodes are then checked for patterns until the depth first search is exhausted.

source
EAGO.Script.register_substitution! — Function
register_substitution!

Specifies that the src::Template_Graph should be subsituted out for the trg::Template_Graph.

Conventions for substition, the expression to be checked always appears at key 1 in the Template_Graph and operations are ordered from low value to high value left to right so if 1 is a -, and 4 => 1, 3 => 1 then the expression is 4 - 3

source
EAGO.Script.Template_Graph — Type
Template_Graph

Holds a list of Template_Nodes, set of directed edges, lengths, an adjacency matrix and the number of children.

source
EAGO.Script.Template_Node — Type
Template_Node

A structure which holds a symbol indicating whether the node is an operator, a number, or an expression type, a value which identifies the function or symbol value, potentially a numeric value num_value, and a check that can be run to verify the node is correct check.

source

UDF Scrubber

Missing docstring.

Missing docstring for scrub. Check Documenter's build log for details.

Missing docstring.

Missing docstring for scrub!. Check Documenter's build log for details.

diff --git a/dev/quick_start/qs_landing/index.html b/dev/quick_start/qs_landing/index.html index 814f3ec9..da4b17c8 100644 --- a/dev/quick_start/qs_landing/index.html +++ b/dev/quick_start/qs_landing/index.html @@ -1,2 +1,2 @@ -Quick Start · EAGO.jl
GitHub

Quick Start

EAGO is a global optimizer primarily meant to be used with the JuMP algebraic modeling language. Typical use will involve installing EAGO and JuMP, creating a problem using JuMP syntax, and passing the problem to the Optimizer.

Customization

EAGO is designed to be easily extensible. Some of the examples that follow include use cases where the standard EAGO functionality is overloaded and readily incorporated into the main optimization routine. Information on how to extend the main branch-and-bound functions (including lower and upper-bounding routines) can be found in the Customization Guidelines section.

Examples

The following pages in this section include several representative examples of how EAGO can be used. Additional (and in some cases, shortened) examples can be found in the EAGO-notebooks repository. Examples and instructional pages in this section include:

  • Standard-Use Example 1: A base-case optimization problem solved using the EAGO optimizer. No extensions or function overloading required.
  • Standard-Use Example 2: An interval bounding example where the user redefines EAGO's lower and upper-bounding functions.
  • Advanced-Use Example 1: A quasiconvex optimization problem solved by overloading some of EAGO's functionality to implement a bisection-based algorithm instead of typical branch-and-bound.
  • Advanced-Use Example 2: Overloading the branch-and-bound algorithm with a custom extension type.
+Quick Start · EAGO.jl
GitHub

Quick Start

EAGO is a global optimizer primarily meant to be used with the JuMP algebraic modeling language. Typical use will involve installing EAGO and JuMP, creating a problem using JuMP syntax, and passing the problem to the Optimizer.

Customization

EAGO is designed to be easily extensible. Some of the examples that follow include use cases where the standard EAGO functionality is overloaded and readily incorporated into the main optimization routine. Information on how to extend the main branch-and-bound functions (including lower and upper-bounding routines) can be found in the Customization Guidelines section.

Examples

The following pages in this section include several representative examples of how EAGO can be used. Additional (and in some cases, shortened) examples can be found in the EAGO-notebooks repository. Examples and instructional pages in this section include:

  • Standard-Use Example 1: A base-case optimization problem solved using the EAGO optimizer. No extensions or function overloading required.
  • Standard-Use Example 2: An interval bounding example where the user redefines EAGO's lower and upper-bounding functions.
  • Advanced-Use Example 1: A quasiconvex optimization problem solved by overloading some of EAGO's functionality to implement a bisection-based algorithm instead of typical branch-and-bound.
  • Advanced-Use Example 2: Overloading the branch-and-bound algorithm with a custom extension type.
diff --git a/dev/ref/index.html b/dev/ref/index.html index 261b5010..4823ab61 100644 --- a/dev/ref/index.html +++ b/dev/ref/index.html @@ -1,2 +1,2 @@ -References · EAGO.jl
GitHub

References

Branch and Bound

  • Floudas, CA (2013). Deterministic global optimization: theory, methods and applications. Vol. 37. Springer Science & Business Media.
  • Horst, R, Tuy, H (2013). Global optimization: Deterministic approaches. Springer Science & Business Media.

Parametric Interval Techniques

  • Hansen ER, Walster GW (2004). Global Optimization Using Interval Analysis. Marcel Dekker, New York, second edition.
  • Krawczyk R (1969). Newton-algorithmen zur bestimmung con nullstellen mit fehler-schranken. Computing, 4:187–201.
  • Krawczyk R (1984). Interval iterations for including a set of solutions. Computing, 32:13–31.
  • Miranda C (1940). Un’osservatione su un teorema di brower. Boll. Un. Mat. Ital., 3:5–7.
  • Neumaier A (1990). Interval Methods for Systems of Equations. Cambridge University Press, Cambridge.
  • Moore RE (1977). A test for existence of solutions to nonlinear systems. SIAM Journal on Numerical Analysis, 14(4):611–615.

Domain Reduction

  • Benhamou F, & Older WJ (1997). Applying interval arithmetic to real, integer, and boolean constraints. The Journal of Logic Programming, 32, 1–24.
  • Caprara A, & Locatelli M (2010). Global optimization problems and domain reduction strategies. Mathematical Programming, 125, 123–137.
  • Gleixner AM, Berthold T, Müller B, & Weltge S (2016). Three enhancements for optimization-based bound tightening. ZIB Report, 15–16.
  • Ryoo HS, & Sahinidis NV (1996). A branch-and-reduce approach to global optimization. Journal of Global Optimization, 8, 107–139.
  • Schichl H, & Neumaier A (2005). Interval analysis on directed acyclic graphs for global optimization. Journal of Global Optimization, 33, 541–562.
  • Tawarmalani, M, & Sahinidis, NV (2005). A polyhedral branch-and-cut approach to global optimization. Mathematical Programming, 103, 225–249.
  • Vu, X, Schichl, H, & Sam-Haroud, D (2009). Interval propagation and search on directed acyclic graphs for numerical constraint solving. Journal of Global Optimization, 45, 499–531.

Generalized McCormick Relaxations

  • Chachuat, B (2014). MC++: a toolkit for bounding factorable functions, v1.0. Retrieved 2 July 2014 https://projects.coin-or.org/MCpp
  • Mitsos A, Chachuat B, and Barton PI. (2009). McCormick-based relaxations of algorithms. SIAM Journal on Optimization, 20(2):573–601.
  • McCormick, GP (1976).. Computability of global solutions to factorable nonconvex programs: Part I-Convex underestimating problems. Mathematical Programming, 10:147–175.
  • McCormick, GP (1983). Nonlinear programming: Theory, Algorithms, and Applications. Wiley, New York.
  • Scott JK, Stuber MD, and Barton PI. (2011). Generalized McCormick relaxations. Journal of Global Optimization, 51(4):569–606.
  • Stuber MD, Scott JK, Barton PI (2015). Convex and concave relaxations of implicit functions. Optim. Methods Softw. 30(3), 424–460
  • Tsoukalas A and Mitsos A (2014). Multivariate McCormick Relaxations. Journal of Global Optimization, 59:633–662.
  • Khan KA, Watson HAJ, Barton PI (2017). Differentiable McCormick relaxations. Journal of Global Optimization, 67(4):687-729.
  • Wechsung A, Scott JK, Watson HAJ, and Barton PI. (2015). Reverse propagation of McCormick relaxations. Journal of Global Optimization 63(1):1-36.

Semi-Infinite Programming

  • Mitsos A (2009). Global optimization of semi-infinite programs via restriction of the right-hand side. Optimization, 60(10-11):1291-1308.
  • Stuber MD and Barton PI (2015). Semi-Infinite Optimization With Implicit Functions. Industrial & Engineering Chemistry Research, 54:307-317, 2015.
+References · EAGO.jl
GitHub

References

Branch and Bound

  • Floudas, CA (2013). Deterministic global optimization: theory, methods and applications. Vol. 37. Springer Science & Business Media.
  • Horst, R, Tuy, H (2013). Global optimization: Deterministic approaches. Springer Science & Business Media.

Parametric Interval Techniques

  • Hansen ER, Walster GW (2004). Global Optimization Using Interval Analysis. Marcel Dekker, New York, second edition.
  • Krawczyk R (1969). Newton-algorithmen zur bestimmung con nullstellen mit fehler-schranken. Computing, 4:187–201.
  • Krawczyk R (1984). Interval iterations for including a set of solutions. Computing, 32:13–31.
  • Miranda C (1940). Un’osservatione su un teorema di brower. Boll. Un. Mat. Ital., 3:5–7.
  • Neumaier A (1990). Interval Methods for Systems of Equations. Cambridge University Press, Cambridge.
  • Moore RE (1977). A test for existence of solutions to nonlinear systems. SIAM Journal on Numerical Analysis, 14(4):611–615.

Domain Reduction

  • Benhamou F, & Older WJ (1997). Applying interval arithmetic to real, integer, and boolean constraints. The Journal of Logic Programming, 32, 1–24.
  • Caprara A, & Locatelli M (2010). Global optimization problems and domain reduction strategies. Mathematical Programming, 125, 123–137.
  • Gleixner AM, Berthold T, Müller B, & Weltge S (2016). Three enhancements for optimization-based bound tightening. ZIB Report, 15–16.
  • Ryoo HS, & Sahinidis NV (1996). A branch-and-reduce approach to global optimization. Journal of Global Optimization, 8, 107–139.
  • Schichl H, & Neumaier A (2005). Interval analysis on directed acyclic graphs for global optimization. Journal of Global Optimization, 33, 541–562.
  • Tawarmalani, M, & Sahinidis, NV (2005). A polyhedral branch-and-cut approach to global optimization. Mathematical Programming, 103, 225–249.
  • Vu, X, Schichl, H, & Sam-Haroud, D (2009). Interval propagation and search on directed acyclic graphs for numerical constraint solving. Journal of Global Optimization, 45, 499–531.

Generalized McCormick Relaxations

  • Chachuat, B (2014). MC++: a toolkit for bounding factorable functions, v1.0. Retrieved 2 July 2014 https://projects.coin-or.org/MCpp
  • Mitsos A, Chachuat B, and Barton PI. (2009). McCormick-based relaxations of algorithms. SIAM Journal on Optimization, 20(2):573–601.
  • McCormick, GP (1976).. Computability of global solutions to factorable nonconvex programs: Part I-Convex underestimating problems. Mathematical Programming, 10:147–175.
  • McCormick, GP (1983). Nonlinear programming: Theory, Algorithms, and Applications. Wiley, New York.
  • Scott JK, Stuber MD, and Barton PI. (2011). Generalized McCormick relaxations. Journal of Global Optimization, 51(4):569–606.
  • Stuber MD, Scott JK, Barton PI (2015). Convex and concave relaxations of implicit functions. Optim. Methods Softw. 30(3), 424–460
  • Tsoukalas A and Mitsos A (2014). Multivariate McCormick Relaxations. Journal of Global Optimization, 59:633–662.
  • Khan KA, Watson HAJ, Barton PI (2017). Differentiable McCormick relaxations. Journal of Global Optimization, 67(4):687-729.
  • Wechsung A, Scott JK, Watson HAJ, and Barton PI. (2015). Reverse propagation of McCormick relaxations. Journal of Global Optimization 63(1):1-36.

Semi-Infinite Programming

  • Mitsos A (2009). Global optimization of semi-infinite programs via restriction of the right-hand side. Optimization, 60(10-11):1291-1308.
  • Stuber MD and Barton PI (2015). Semi-Infinite Optimization With Implicit Functions. Industrial & Engineering Chemistry Research, 54:307-317, 2015.
diff --git a/dev/search_index.js b/dev/search_index.js index 879b3c71..3c350112 100644 --- a/dev/search_index.js +++ b/dev/search_index.js @@ -1,3 +1,3 @@ var documenterSearchIndex = {"docs": -[{"location":"mccormick/usage/#Basic-Usage","page":"Basic Usage","title":"Basic Usage","text":"","category":"section"},{"location":"mccormick/usage/#Bounding-a-Univariate-Function","page":"Basic Usage","title":"Bounding a Univariate Function","text":"","category":"section"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"In order to bound a function using a McCormick relaxation, you first construct a McCormick object (x::MC) that bounds the input variables, and then you pass these variables to the desired function.","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"In the example below, convex/concave relaxations of the function f(x) = x (x - 5) sin(x) are calculated at x = 2 on the interval 1 4.","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"using McCormick\n\n# Create MC object for x = 2.0 on [1.0, 4.0] for relaxing\n# a function f(x) on the interval Intv\n\nf(x) = x*(x - 5.0)*sin(x)\n\nx = 2.0 # Value of independent variable x\nIntv = Interval(1.0, 4.0) # Define interval to relax over\n # Note that McCormick.jl reexports IntervalArithmetic.jl\n # and StaticArrays. So no using statement for these is\n # necessary.\n# Create McCormick object\nxMC = MC{1,NS}(x, Intv, 1)\n\nfMC = f(xMC) # Relax the function\n\ncv = fMC.cv # Convex relaxation\ncc = fMC.cc # Concave relaxation\ncvgrad = fMC.cv_grad # Subgradient/gradient of convex relaxation\nccgrad = fMC.cc_grad # Subgradient/gradient of concave relaxation\nIv = fMC.Intv # Retrieve interval bounds of f(x) on Intv","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"By plotting the results we can easily visualize the convex and concave relaxations, interval bounds, and affine bounds constructed using the subgradient at the middle of X.","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"(Image: Figure_1)","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"If we instead use the constructor xMC = MC{1,Diff}(x, Intv, 1) in the above code and re-plot, we arrive at the following graph. Note that these relaxations are differentiable, but not as tight as the nonsmooth relaxations.","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"(Image: Figure_2)","category":"page"},{"location":"mccormick/usage/#Bounding-a-Multivariate-Function","page":"Basic Usage","title":"Bounding a Multivariate Function","text":"","category":"section"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"This can readily be extended to multivariate functions, for example:","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"beginaligned\nf(xy) = big(4 - 21 x^2 + fracx^46 big) x^2 + x y + (-4 + 4 y^2) y^2\nendaligned","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"using McCormick\n\n# Define function\nf(x, y) = (4.0 - 2.1*x^2 + (x^4)/6.0)*x^2 + x*y + (-4.0 + 4.0*y^2)*y^2\n\n# Define intervals for independent variables\nn = 30\nX = Interval{Float64}(-2,0)\nY = Interval{Float64}(-0.5, 0.5)\nxrange = range(X.lo, stop=X.hi, length=n)\nyrange = range(Y.lo, stop=Y.hi, length=n)\n\n# Calculate differentiable McCormick relaxation\nfor (i,x) in enumerate(xrange)\n for (j,y) in enumerate(yrange)\n z = f(x, y) # Calculate function values\n xMC = MC{1,Diff}(x, X, 1) # Differentiable relaxation for x\n yMC = MC{1,Diff}(y, Y, 2) # Differentiable relaxation for y\n fMC = f(xMC, yMC) # Relax the function\n cv = fMC.cv # Convex relaxation\n cc = fMC.cc # Concave relaxation\n end\nend","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"(Image: Figure_3)","category":"page"},{"location":"mccormick/operators/#Currently-Supported-Operators","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"","category":"section"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"The operators currently supported are listed below. The operators with a check box have been subject to a large degree of scrutiny and have been implemented for both forward and reverse McCormick relaxations (Wechsung2015). Each McCormick object is associated with a parameter T <: RelaxTag which is either NS for nonsmooth relaxations (Mitsos2009, Scott2011), MV for multivariate relaxations (Tsoukalas2014, Najman2017), or Diff for differentiable relaxations (Khan2016, Khan2018, Khan2019). Conversion between NS, MV, and Diff relax tags is not currently supported. Convex and concave envelopes are used to compute relaxations of univariate functions.","category":"page"},{"location":"mccormick/operators/#Univariate-McCormick-Operators","page":"Currently Supported Operators","title":"Univariate McCormick Operators","text":"","category":"section"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"Arbitrarily differentiable relaxations can be constructed for the following operators:","category":"page"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"Inverse (inv)\nLogarithms (log, log2, log10)\nExponential Functions (exp, exp2, exp10)\nSquare Root (sqrt)\nAbsolute Value (abs)","category":"page"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"Both nonsmooth and Whitney-1 (once differentiable) relaxations are supported for the following operators:","category":"page"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"Step Functions (step, sign)\nTrigonometric Functions (sin, cos, tan)\nInverse Trigonometric Functions (asin, acos, atan)\nHyperbolic Functions (sinh, cosh, tanh)\nInverse Hyperbolic Functions (asinh, acosh, atanh)\nCommon Activation Functions (relu, leaky_relu, param_relu, sigmoid, bisigmoid, softsign, softplus, maxtanh, pentanh, gelu, elu, selu, swish)\nSpecial Functions (erf)","category":"page"},{"location":"mccormick/operators/#Bivariate-McCormick-Operators","page":"Currently Supported Operators","title":"Bivariate McCormick Operators","text":"","category":"section"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"The following bivariate operators are supported for two MC objects. Both nonsmooth and Whitney-1 (once differentiable) relaxations are supported.","category":"page"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"Multiplication (*)\nDivision (/)","category":"page"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"Arbitrarily differentiable relaxations can be constructed for the following operators:","category":"page"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"Addition (+)\nSubtraction (-)\nMinimization (min)\nMaximization (max)","category":"page"},{"location":"mccormick/operators/#Common-Subexpressions","page":"Currently Supported Operators","title":"Common Subexpressions","text":"","category":"section"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"The following functions can be used in place of common subexpressions encountered in optimization and will result in improved performance (in each case, the standard McCormick composition rules are often more expansive).","category":"page"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"xexpax\narh\nxlogx\nmm","category":"page"},{"location":"mccormick/operators/#McCormick.xexpax","page":"Currently Supported Operators","title":"McCormick.xexpax","text":"expax\n\nThe expax function is defined as expax(x, a) = x*exp(a*x).\n\nForm defined in Najman, Jaromił, Dominik Bongartz, and Alexander Mitsos. \"Relaxations of thermodynamic property and costing models in process engineering.\" Computers & Chemical Engineering 130 (2019): 106571.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.arh","page":"Currently Supported Operators","title":"McCormick.arh","text":"arh\n\nThe arrhenius function arh is defined as arh(x) = exp(-k/x).\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.xlogx","page":"Currently Supported Operators","title":"McCormick.xlogx","text":"xlogx\n\nThe function xlogx is defined as xlogx(x) = x*log(x).\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.mm","page":"Currently Supported Operators","title":"McCormick.mm","text":"mm(X,v,K) = v*X / (X + K)\n\nA Michaelis-Menten rate function.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#Bound-Setting-Functions","page":"Currently Supported Operators","title":"Bound Setting Functions","text":"","category":"section"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"The following functions are used to specify that known bounds on a subexpression exist and that the relaxation/interval bounds propagated should make use of this information. The utility functions can be helpful in avoiding domain violations that arise due to the overly expansive nature of composite relaxations. Improper use of these functions may lead to cases in which the resulting relaxations are empty, so the user is encouraged to use discretion.","category":"page"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"positive\nnegative\nlower_bnd\nupper_bnd\nbnd","category":"page"},{"location":"mccormick/operators/#McCormick.positive","page":"Currently Supported Operators","title":"McCormick.positive","text":"positive(x::MC)\n\nSets the lower interval bound and the convex relaxation of x to a value of at least McCormick.MC_DOMAIN_TOL. (Sub)gradients are adjusted appropriately.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.negative","page":"Currently Supported Operators","title":"McCormick.negative","text":"negative(x::MC)\n\nSets the upper interval bound and the concave relaxation of x to a value of at most -McCormick.MC_DOMAIN_TOL. (Sub)gradients are adjusted appropriately.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.lower_bnd","page":"Currently Supported Operators","title":"McCormick.lower_bnd","text":"lower_bnd(x::MC, lb::Float64)\n\nSets the lower interval bound and the convex relaxation of x to a value of at least lb. (Sub)gradients are adjusted appropriately.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.upper_bnd","page":"Currently Supported Operators","title":"McCormick.upper_bnd","text":"upper_bnd(x::MC, ub)\n\nSets the upper interval bound and the concave relaxation of x to a value of at most ub. (Sub)gradients are adjusted appropriately.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.bnd","page":"Currently Supported Operators","title":"McCormick.bnd","text":"bnd(x::MC, lb, ub)\n\nSets the lower interval bound and the convex relaxation of x to a value of at least lb. Sets the upper interval bound and the concave relaxation of x to a value of at most ub. (Sub)gradients are adjusted appropriately.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#Specialized-Activation-Functions","page":"Currently Supported Operators","title":"Specialized Activation Functions","text":"","category":"section"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":" pentanh\n leaky_relu\n param_relu\n maxtanh","category":"page"},{"location":"mccormick/operators/#McCormick.pentanh","page":"Currently Supported Operators","title":"McCormick.pentanh","text":"pentanh\n\nThe pentanh activation function pentanh(x) = x > 0.0 ? tanh(x) : tanh(0.25*x).\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.leaky_relu","page":"Currently Supported Operators","title":"McCormick.leaky_relu","text":"leaky_relu\n\nThe leaky Rectified Linear Unit activation function leaky_relu(x) = max(x, 0.01x).\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.param_relu","page":"Currently Supported Operators","title":"McCormick.param_relu","text":"param_relu\n\nThe parametric Rectified Linear Unit activation function param_relu(x, α) = (max(x, αx) with α in [0,1].\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.maxtanh","page":"Currently Supported Operators","title":"McCormick.maxtanh","text":"maxtanh\n\nThe maxtanh activation function maxtanh(x) = max(x, tanh(x)).\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#References","page":"Currently Supported Operators","title":"References","text":"","category":"section"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"Khan KA, Watson HAJ, Barton PI (2017). Differentiable McCormick relaxations. Journal of Global Optimization, 67(4): 687-729.\nKhan KA, Wilhelm ME, Stuber MD, Cao H, Watson HAJ, Barton PI (2018). Corrections to: Differentiable McCormick relaxations. Journal of Global Optimization, 70(3): 705-706.\nKhan KA (2019). Whitney differentiability of optimal-value functions for bound-constrained convex programming problems. Optimization, 68(2-3): 691-711\nMitsos A, Chachuat B, and Barton PI. (2009). McCormick-based relaxations of algorithms. SIAM Journal on Optimization, 20(2): 573–601.\nNajman J, Bongratz D, Tsoukalas A, and Mitsos A (2017). Erratum to: Multivariate McCormick relaxations. Journal of Global Optimization, 68: 219-225.\nScott JK, Stuber MD, and Barton PI. (2011). Generalized McCormick relaxations. Journal of Global Optimization, 51(4): 569–606.\nStuber MD, Scott JK, Barton PI (2015). Convex and concave relaxations of implicit functions. Optim. Methods Softw., 30(3): 424–460\nTsoukalas A and Mitsos A (2014). Multivariate McCormick Relaxations. Journal of Global Optimization, 59:633–662.\nWechsung A, Scott JK, Watson HAJ, and Barton PI. (2015). Reverse propagation of McCormick relaxations. Journal of Global Optimization, 63(1): 1-36.","category":"page"},{"location":"quick_start/qs_landing/#Quick-Start","page":"Quick Start","title":"Quick Start","text":"","category":"section"},{"location":"quick_start/qs_landing/","page":"Quick Start","title":"Quick Start","text":"EAGO is a global optimizer primarily meant to be used with the JuMP algebraic modeling language. Typical use will involve installing EAGO and JuMP, creating a problem using JuMP syntax, and passing the problem to the Optimizer. ","category":"page"},{"location":"quick_start/qs_landing/#Customization","page":"Quick Start","title":"Customization","text":"","category":"section"},{"location":"quick_start/qs_landing/","page":"Quick Start","title":"Quick Start","text":"EAGO is designed to be easily extensible. Some of the examples that follow include use cases where the standard EAGO functionality is overloaded and readily incorporated into the main optimization routine. Information on how to extend the main branch-and-bound functions (including lower and upper-bounding routines) can be found in the Customization Guidelines section.","category":"page"},{"location":"quick_start/qs_landing/#Examples","page":"Quick Start","title":"Examples","text":"","category":"section"},{"location":"quick_start/qs_landing/","page":"Quick Start","title":"Quick Start","text":"The following pages in this section include several representative examples of how EAGO can be used. Additional (and in some cases, shortened) examples can be found in the EAGO-notebooks repository. Examples and instructional pages in this section include:","category":"page"},{"location":"quick_start/qs_landing/","page":"Quick Start","title":"Quick Start","text":"Standard-Use Example 1: A base-case optimization problem solved using the EAGO optimizer. No extensions or function overloading required.\nStandard-Use Example 2: An interval bounding example where the user redefines EAGO's lower and upper-bounding functions.\nAdvanced-Use Example 1: A quasiconvex optimization problem solved by overloading some of EAGO's functionality to implement a bisection-based algorithm instead of typical branch-and-bound.\nAdvanced-Use Example 2: Overloading the branch-and-bound algorithm with a custom extension type.","category":"page"},{"location":"optimizer/relax_back/#Nonlinear-Backend","page":"Nonlinear Backend","title":"Nonlinear Backend","text":"","category":"section"},{"location":"optimizer/relax_back/#Graphs,-Caches,-Forward-and-Reverse-Propagation","page":"Nonlinear Backend","title":"Graphs, Caches, Forward and Reverse Propagation","text":"","category":"section"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":"EAGO makes use of a specialized tape structure for each function in order to compute valid composite bounds and relaxations. Each variable, constant, and expression is represented by a node in a directed graph structure. ","category":"page"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":" EAGO.Node\n EAGO.NodeClass\n EAGO.AtomType","category":"page"},{"location":"optimizer/relax_back/#EAGO.Node","page":"Nonlinear Backend","title":"EAGO.Node","text":"struct Node <: EAGO.AbstractNode\n\nDescribes connectivity and expression represented by node.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/#EAGO.NodeClass","page":"Nonlinear Backend","title":"EAGO.NodeClass","text":"NodeType\n\nEach node in the directed graph can be classified into the following types\n\nVARIABLE: Denotes a decision variable.\nPARAMETER: An adjustable parameter value (not a decision variable).\nCONSTANT: A constant value\nEXPRESSION: Any other expression that isn't a subexpression\nSUBEXPRESSION: Any expression referencing a different graph representation.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/#EAGO.AtomType","page":"Nonlinear Backend","title":"EAGO.AtomType","text":"AtomType\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":" EAGO.AbstractDirectedGraph\n EAGO.DirectedTree","category":"page"},{"location":"optimizer/relax_back/#EAGO.AbstractDirectedGraph","page":"Nonlinear Backend","title":"EAGO.AbstractDirectedGraph","text":"abstract type AbstractDirectedGraph\n\nAbstract supertype for generic directed graph structure.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/#EAGO.DirectedTree","page":"Nonlinear Backend","title":"EAGO.DirectedTree","text":"DirectedTree\n\nA tree graph with a single sink node.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":"Each field of the ith EAGO.Node using a basic access function. For instance the ith node's ex_type for graph d may be accessed by ex_type(d, i). The sparsity of node i returns an ordered list of children nodes which form the argument tuple for the operator performed at node i. The sparsity of node i returns a list of parent nodes which form the argument tuple for the operator performed at node i. The parameter_values and constant_values functions are used to access the ith parameter values or ith constant values.","category":"page"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":"EAGO organizes information associated with each node in a given graph structure using an EAGO.AbstractCache which stores the given information.","category":"page"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":" EAGO.AbstractCache\n EAGO.initialize!(::AbstractCache, ::AbstractDirectedGraph)","category":"page"},{"location":"optimizer/relax_back/#EAGO.AbstractCache","page":"Nonlinear Backend","title":"EAGO.AbstractCache","text":"abstract type AbstractCache\n\nAbstract supertype used for information storage object the directed acyclic graph.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/#EAGO.initialize!-Tuple{AbstractCache, AbstractDirectedGraph}","page":"Nonlinear Backend","title":"EAGO.initialize!","text":"initialize!(_::AbstractCache, _::AbstractDirectedGraph)\n\n\nFunction used to initialize the storage cache d::AbstractCache for a given type of directed acyclic graph g::AbstractDirectedGraph.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":"Information in a given EAGO.AbstractCache is populated by performing a series of forward and reverse passes of the graph structure which dispatch off of an EAGO.AbstractCacheAttribute which indicates what particular information is desired.","category":"page"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":" EAGO.AbstractCacheAttribute","category":"page"},{"location":"optimizer/relax_back/#EAGO.AbstractCacheAttribute","page":"Nonlinear Backend","title":"EAGO.AbstractCacheAttribute","text":"abstract type AbstractCacheAttribute\n\nAbstract supertype used for attributes stored in a cache.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":"Three included AbstractCacheAttributes are used to ","category":"page"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":" EAGO.Relax\n EAGO.RelaxAA\n EAGO.RelaxMulEnum","category":"page"},{"location":"optimizer/relax_back/#EAGO.Relax","page":"Nonlinear Backend","title":"EAGO.Relax","text":"Relax\n\nUsed to dispatch relaxations to a standard \n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/#EAGO.RelaxAA","page":"Nonlinear Backend","title":"EAGO.RelaxAA","text":"RelaxAA\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/#EAGO.RelaxMulEnum","page":"Nonlinear Backend","title":"EAGO.RelaxMulEnum","text":"RelaxMulEnum\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":"The forward and reverse routines are overloaded as follows:","category":"page"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":" EAGO.f_init!(t::AbstractCacheAttribute, g::AbstractDirectedGraph, c::AbstractCache)\n EAGO.fprop!(t::AbstractCacheAttribute, v::Variable, g::AbstractDirectedGraph, c::AbstractCache, k::Int)\n EAGO.fprop!(t::AbstractCacheAttribute, v::Subexpression, g::AbstractDirectedGraph, c::AbstractCache, k::Int)\n EAGO.fprop!(t::AbstractCacheAttribute, v::Expression, g::AbstractDirectedGraph, c::AbstractCache, k::Int)\n EAGO.fprop!(t::AbstractCacheAttribute, v::Parameter, g::AbstractDirectedGraph, c::AbstractCache, k::Int)\n EAGO.fprop!(t::AbstractCacheAttribute, v::Constant, g::AbstractDirectedGraph, c::AbstractCache, k::Int)","category":"page"},{"location":"optimizer/relax_back/#EAGO.f_init!-Tuple{AbstractCacheAttribute, AbstractDirectedGraph, AbstractCache}","page":"Nonlinear Backend","title":"EAGO.f_init!","text":"Initializes information in cache c for each node in g that may be used in a forward-pass of attribute t. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Variable, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a variable v at index k in cache c associated with graph g using information at index k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Subexpression, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a subexpression v at index k in cache c associated with graph g using information taken from the children of k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Expression, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a expression v at index k in cache c associated with graph g using information taken from the children of k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Parameter, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a parameter v at index k in cache c associated with graph g using information at index k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Constant, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a constant v at index k in cache c associated with graph g using information at index k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":" EAGO.r_init!(t::AbstractCacheAttribute, g::AbstractDirectedGraph, c::AbstractCache)\n EAGO.rprop!(t::AbstractCacheAttribute, v::Variable, g::AbstractDirectedGraph, c::AbstractCache, k::Int)\n EAGO.rprop!(t::AbstractCacheAttribute, v::Subexpression, g::AbstractDirectedGraph, c::AbstractCache, k::Int)\n EAGO.rprop!(t::AbstractCacheAttribute, v::Expression, g::AbstractDirectedGraph, c::AbstractCache, k::Int)\n EAGO.rprop!(t::AbstractCacheAttribute, v::Parameter, g::AbstractDirectedGraph, c::AbstractCache, k::Int)\n EAGO.rprop!(t::AbstractCacheAttribute, v::Constant, g::AbstractDirectedGraph, c::AbstractCache, k::Int)","category":"page"},{"location":"optimizer/relax_back/#EAGO.r_init!-Tuple{AbstractCacheAttribute, AbstractDirectedGraph, AbstractCache}","page":"Nonlinear Backend","title":"EAGO.r_init!","text":"Initializes information in cache c for each node in g that may be used in a reverse-pass of attribute t. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Variable, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a variable v at index k in cache c associated with graph g using information at index k taken from the parents of k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Subexpression, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a subexpressions v at index k in cache c associated with graph g using information at index k taken from the parents of k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Expression, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a expressions v at index k in cache c associated with graph g using information at index k taken from the parents of k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Parameter, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a parameters v at index k in cache c associated with graph g using information at index k taken from the parents of k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Constant, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a constant v at index k in cache c associated with graph g using information at index k taken from the parents of k.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":"Forward and reverse subroutines are overloaded for individual operators using through functions of the forms fprop!(t::AbstractCacheAttribute, v::Val{AtomType}, g::AbstractDirectedGraph, b::AbstractCache, k::Int) and rprop!(t::AbstractCacheAttribute, v::Val{AtomType}, g::AbstractDirectedGraph, b::AbstractCache, k::Int). ","category":"page"},{"location":"optimizer/relax_back/#Other-Routines","page":"Nonlinear Backend","title":"Other Routines","text":"","category":"section"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":" EAGO.is_safe_cut!(m::GlobalOptimizer, f::MathOptInterface.ScalarAffineFunction{Float64}) ","category":"page"},{"location":"optimizer/relax_back/#EAGO.is_safe_cut!-Tuple{GlobalOptimizer, MathOptInterface.ScalarAffineFunction{Float64}}","page":"Nonlinear Backend","title":"EAGO.is_safe_cut!","text":"is_safe_cut!(\n m::GlobalOptimizer,\n f::MathOptInterface.ScalarAffineFunction{Float64}\n) -> Bool\n\n\nApplies the safe cut checks detailed in Khajavirad, 2018 [Khajavirad, Aida, and Nikolaos V. Sahinidis. \"A hybrid LP/NLP paradigm for global optimization relaxations.\" Mathematical Programming Computation 10.3 (2018): 383-421] to ensure that only numerically safe affine relaxations are added. Checks that:\n\n|b| <= safe b, \nsafe_l <= abs(ai) <= safe u, and \nsafe_l <= abs(ai/aj) <= safe_u.\n\n\n\n\n\n","category":"method"},{"location":"mccormick/type/#Types","page":"Types","title":"Types","text":"","category":"section"},{"location":"mccormick/type/","page":"Types","title":"Types","text":"McCormick.MC\nMcCormick.RelaxTag","category":"page"},{"location":"mccormick/type/#McCormick.MC","page":"Types","title":"McCormick.MC","text":"struct MC{N, T<:RelaxTag} <: Real\n\nMC{N, T <: RelaxTag} <: Real is the McCormick (w/ (sub)gradient) structure which is used to overload standard calculations. The fields are:\n\ncv::Float64: Convex relaxation\ncc::Float64: Concave relaxation\nIntv::Interval{Float64}: Interval bounds\ncv_grad::SVector{N, Float64} where N: (Sub)gradient of convex relaxation\ncc_grad::SVector{N, Float64} where N: (Sub)gradient of concave relaxation\ncnst::Bool: Boolean indicating whether the relaxations are constant over the domain. True if bounding an interval/constant. False, otherwise. This may change over the course of a calculation cnst for zero(x) is true even if x.cnst is false.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/type/#McCormick.RelaxTag","page":"Types","title":"McCormick.RelaxTag","text":"abstract type RelaxTag\n\nAn abstract type the subtypes of which define the manner of relaxation that will be performed for each operator applied to the MC object. Currently, the struct NS which specifies that standard (Mitsos 2009) are to be used is fully supported. Limited support is provided for differentiable McCormick relaxations specified by struct Diff (Khan 2017) and struct MV struct MV (Tsoukalas 2011.) A rounding-safe implementation of the standard McCormick relaxations is specified by the struct NSSafe which is work in progress.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/type/#Constructors-for-MC","page":"Types","title":"Constructors for MC","text":"","category":"section"},{"location":"mccormick/type/","page":"Types","title":"Types","text":"MC{N,T}(y::Float64)","category":"page"},{"location":"mccormick/type/#McCormick.MC-Union{Tuple{Float64}, Tuple{T}, Tuple{N}} where {N, T}","page":"Types","title":"McCormick.MC","text":"MC{N,T}(y::Interval{Float64})\n\nConstructs a McCormick relaxation with the convex relaxation equal to y.lo and concave relaxation equal to y.hi.\n\n\n\n\n\nMC{N,T}(y::Float64)\n\nConstructs a McCormick relaxation with the convex relaxation equal to y and concave relaxation equal to y.\n\n\n\n\n\n","category":"method"},{"location":"mccormick/type/#Internal-Utilities","page":"Types","title":"Internal Utilities","text":"","category":"section"},{"location":"mccormick/type/","page":"Types","title":"Types","text":"mid3\nmid3v\nmid_grad\ndline_seg\nseed_gradient\ncut\nsecant\nnewton\nMcCormick.golden_section_it\nMcCormick.golden_section","category":"page"},{"location":"mccormick/type/#McCormick.mid3","page":"Types","title":"McCormick.mid3","text":"mid3(\n x::Float64,\n y::Float64,\n z::Float64\n) -> Tuple{Float64, Int64}\n\n\nCalculates the middle of three numbers returning the value and the index where x >= y.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.mid3v","page":"Types","title":"McCormick.mid3v","text":"mid3v(x::Float64, y::Float64, z::Float64) -> Float64\n\n\nCalculates the middle of three numbers (x,y,z) returning the value where x <= y.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.mid_grad","page":"Types","title":"McCormick.mid_grad","text":"mid_grad(\n cc_grad::SArray{Tuple{N}, Float64, 1, N},\n cv_grad::SArray{Tuple{N}, Float64, 1, N},\n id::Int64\n) -> Any\n\n\nTakes the concave relaxation gradient 'ccgrad', the convex relaxation gradient 'cvgrad', and the index of the midpoint returned 'id' and outputs the appropriate gradient according to McCormick relaxation rules.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.dline_seg","page":"Types","title":"McCormick.dline_seg","text":"dline_seg(\n f::Function,\n df::Function,\n x::Float64,\n xL::Float64,\n xU::Float64\n) -> Tuple{Any, Any}\n\n\nCalculates the value of the slope line segment between (xL, f(xL)) and (xU, f(xU)) defaults to evaluating the derivative of the function if the interval is tight.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.seed_gradient","page":"Types","title":"McCormick.seed_gradient","text":"seed_gradient(j::Int64, x::Val{N}) -> Any\n\n\nCreates a x::SVector{N,Float64} object that is one at x[j] and zero everywhere else.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.cut","page":"Types","title":"McCormick.cut","text":"cut(\n xL::Float64,\n xU::Float64,\n cv::Float64,\n cc::Float64,\n cv_grad::SArray{Tuple{N}, Float64, 1, N},\n cc_grad::SArray{Tuple{N}, Float64, 1, N}\n) -> Tuple{Float64, Float64, Any, Any}\n\n\nRefines convex/concave relaxations cv and cc with associated subgradients cv_grad and cc_grad by intersecting them with the interval boudns xL and xU.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.secant","page":"Types","title":"McCormick.secant","text":"secant(\n x0::Float64,\n x1::Float64,\n xL::Float64,\n xU::Float64,\n f::Function,\n envp1::Float64,\n envp2::Float64\n) -> Tuple{Float64, Bool}\n\n\nDefines a local 1D secant method to solve for the root of f between the bounds xL and xU using x0 and x1 as a starting points. The inputs envp1 and envp2 are the envelope calculation parameters.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.newton","page":"Types","title":"McCormick.newton","text":"newton(\n x0::Float64,\n xL::Float64,\n xU::Float64,\n f::Function,\n df::Function,\n envp1::Float64,\n envp2::Float64\n) -> Tuple{Any, Bool}\n\n\nDefines a local 1D newton method to solve for the root of f between the bounds xL and xU using x0 as a starting point. The derivative of f is df. The inputs envp1 and envp2 are the envelope calculation parameters.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.golden_section_it","page":"Types","title":"McCormick.golden_section_it","text":"golden_section_it(\n init::Int64,\n a::Float64,\n fa::Float64,\n b::Float64,\n fb::Float64,\n c::Float64,\n fc::Float64,\n f::Function,\n envp1::Float64,\n envp2::Float64\n) -> Float64\n\n\nDefine iteration used in golden section method. The inputs fa,fb, and fc, are the function f evaluated at a,b, and c respectively. The inputs envp1 and envp2 are the envelope calculation parameters. The value init is the iteration number of the golden section method.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.golden_section","page":"Types","title":"McCormick.golden_section","text":"golden_section(\n xL::Float64,\n xU::Float64,\n f::Function,\n envp1::Float64,\n envp2::Float64\n) -> Float64\n\n\nDefines a local 1D golden section method to solve for the root of f between the bounds xL and xU using x0 as a starting point. Define iteration used in golden section method. The inputs envp1 and envp2 are the envelope calculation parameters.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#(Under-Development)-MCNoGrad","page":"Types","title":"(Under Development) MCNoGrad","text":"","category":"section"},{"location":"mccormick/type/","page":"Types","title":"Types","text":"A handful of applications make use of McCormick relaxations directly without the need for subgradients. We are currently adding support for a McCormick struct which omits subgradient propagation in favor of return a MCNoGrad object and associated derivative information. This is currently under development and likely lacking key functionality.","category":"page"},{"location":"mccormick/type/","page":"Types","title":"Types","text":" McCormick.MCNoGrad\n MCNoGrad(y::Float64)\n MCNoGrad(y::Interval{Float64})\n MCNoGrad(cv::Float64, cc::Float64)","category":"page"},{"location":"mccormick/type/#McCormick.MCNoGrad","page":"Types","title":"McCormick.MCNoGrad","text":"struct MCNoGrad <: Real\n\nMCNoGrad <: Real is a McCormick structure without RelaxType Tag or subgradients. This structure is used for source-code transformation approaches to constructing McCormick relaxations. Methods definitions and calls should specify the relaxation type used (i.e.) +(::NS, x::MCNoGrad, y::MCNoGrad).... Moreover, the kernel associated with this returns all intermediate calculations necessary to compute subgradient information whereas the overloading calculation simply returns the MCNoGrad object. For univariate calculations without tiepoints such as we log2(::NS, x::MCNoGrad)::MCNoGrad whereas log2_kernel(::NS, x::MCNoGrad, ::Bool) = (::MCNoGrad, cv_id::Int, cc_id::Int, dcv, dcc). Univariate NS functions follow convention (MCNoGrad, cvid, ccid, dcv, dcc, tp1cv, tp1cc, .... tpncv, tpncc) where cv_id is the subgradient selected (1 = cv, 2 = cc, 3 = 0), dcv and dcc are derivatives (or elements of subdifferential) of the outside function evaluated per theorem at the point being evaluated and tpicv, tpicc are the ith tiepoints associated with computing the envelope of the outside function. .\n\ncv::Float64: Convex relaxation\ncc::Float64: Concave relaxation\nIntv::Interval{Float64}: Interval bounds\ncnst::Bool: Boolean indicating whether the relaxations are constant over the domain. True if bounding an interval/constant. False, otherwise. This may change over the course of a calculation cnst for zero(x) is true even if x.cnst is false.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/type/#McCormick.MCNoGrad-Tuple{Float64}","page":"Types","title":"McCormick.MCNoGrad","text":"MCNoGrad(y::Float64)\n\nConstructs McCormick relaxation with convex relaxation equal to y and concave relaxation equal to y.\n\n\n\n\n\n","category":"method"},{"location":"mccormick/type/#McCormick.MCNoGrad-Tuple{Interval{Float64}}","page":"Types","title":"McCormick.MCNoGrad","text":"MCNoGrad(y::Interval{Float64})\n\nConstructs McCormick relaxation with convex relaxation equal to y.lo and concave relaxation equal to y.hi.\n\n\n\n\n\n","category":"method"},{"location":"mccormick/type/#McCormick.MCNoGrad-Tuple{Float64, Float64}","page":"Types","title":"McCormick.MCNoGrad","text":"MCNoGrad(cv::Float64, cc::Float64)\n\nConstructs McCormick relaxation with convex relaxation equal to cv and concave relaxation equal to cc.\n\n\n\n\n\n","category":"method"},{"location":"examples/alpha_bb/#Advanced-Use-Example-2","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"","category":"section"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"This example is also provided here as a Jupyter Notebook.","category":"page"},{"location":"examples/alpha_bb/#An-\\alphaBB-Example-for-a-QCQP.","page":"Advanced-Use Example 2","title":"An alphaBB Example for a QCQP.","text":"","category":"section"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"In this example, we will demonstrate the use of a user-defined lower-bounding problem that uses alphaBB convex relaxations. In this example, we wish to solve the nonconvex quadratically constrained quadratic program (QCQP):","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"beginaligned\n min_mathbf x in mathbbIR^2 frac12 mathbf x^rm T mathbf Q_f mathbf x + mathbf c_f^rm T mathbf x \nrm st g_1(mathbf x) = frac12 mathbf x^rm T mathbf Q_g_1mathbf x + mathbf c_g_1^rm T mathbf x leq 0 \n g_2(mathbf x) = frac12 mathbf x^rm T mathbf Q_g_2 mathbf x + mathbf c_g_2^rm T mathbf x leq 0 \nendaligned","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"with mathbf Q_iinmathbb R^2times 2 not positive semidefinite for any i.","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"using JuMP, EAGO, Ipopt, LinearAlgebra","category":"page"},{"location":"examples/alpha_bb/#Custom-Function-Definitions","page":"Advanced-Use Example 2","title":"Custom Function Definitions","text":"","category":"section"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"For convenience, we'll define the following function that returns all the problem data mathbf Q_i and mathbf c_i.","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"function QCQP_setup()\n\n Qf = [3.0, 3/2; 3/2, -5.0]\n cf = [3.0; 2.0]\n\n Qg1 = [-2.0, 5.0; 5.0, -2.0]\n cg1 = [1.0; 3.0]\n\n Qg2 = [-6.0, 3.0; 3.0, 2.0]\n cg2 = [2.0; 1.0]\n \n return Qf, cf, Qg1, cg1, Qg2, cg2\nend","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"The next function we'll define will take as input data for a particular quadratic function and the interval bounds on the decision variables, and construct an alphaBB convex relaxation of that function. Since we're solving a QCQP, we'll use the eigvals function to directly compute the eigenvalues of the input mathbf Q_i matrix.","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"function αBB_relax(Q::Matrix{T}, c::Vector{T}, xL::Vector{T}, xU::Vector{T}, x::Real...) where {T<:Float64}\n α = max(0.0, -minimum(eigvals(Q))/2)\n y = [x[1]; x[2]]\n cv = 1/2*y'*Q*y + c'*y + α*(xL - y)'*(xU - y)\n return cv\nend","category":"page"},{"location":"examples/alpha_bb/#Redefine-the-Lower-Bounding-Problem","page":"Advanced-Use Example 2","title":"Redefine the Lower-Bounding Problem","text":"","category":"section"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"The following code first defines our EAGO extension (custom version) struct and then it redefines the lower-bounding problem as our own version. That is, when we call this customized version of EAGO to solve the problem, it'll deploy this version of the lower-bounding problem instead of the default version. ","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"import EAGO: Optimizer, GlobalOptimizer\n\nstruct αBB_Convex <: EAGO.ExtensionType end\nimport EAGO: lower_problem!\nfunction EAGO.lower_problem!(t::αBB_Convex, opt::GlobalOptimizer)\n # Get active node\n n = opt._current_node\n # Get bounds on active node for calculating relaxations\n xL = n.lower_variable_bounds[1:2]\n xU = n.upper_variable_bounds[1:2]\n # Get the problem data\n Qf, cf, Qg1, cg1, Qg2, cg2 = QCQP_setup()\n\n # Define the JuMP model and declare the solver\n mL = JuMP.Model(JuMP.optimizer_with_attributes(Ipopt.Optimizer,\n \"tol\" => 1.0e-6,\n \"print_level\" => 0))\n @variable(mL, xL[i] <= x[i=1:2] <= xU[i])\n \n # Define the function closures for the user-defined relaxations\n fcv(x...) = αBB_relax(Qf, cf, xL, xU, x...)\n g1cv(x...) = αBB_relax(Qg1, cg1, xL, xU, x...)\n g2cv(x...) = αBB_relax(Qg2, cg2, xL, xU, x...)\n\n # Register the user-defined functions\n # Note: If the gradients and Hessians are directly available, they could\n # be passed as arguments to the register function to speed things up.\n JuMP.register(mL, :fcv, 2, fcv, autodiff=true)\n JuMP.register(mL, :g1cv, 2, g1cv, autodiff=true)\n JuMP.register(mL, :g2cv, 2, g2cv, autodiff=true)\n\n # Declare the objective function and constraints\n @NLobjective(mL, Min, fcv(x[1], x[2]))\n @NLconstraint(mL, g1cv(x[1], x[2]) <= 0.0)\n @NLconstraint(mL, g2cv(x[1], x[2]) <= 0.0)\n \n # Solve the relaxed problem\n JuMP.optimize!(mL)\n \n # Get primal status, termination status, determine if a global solution was obtained\n tstatus = MOI.get(mL, MOI.TerminationStatus())\n pstatus = MOI.get(mL, MOI.PrimalStatus())\n\n solution = JuMP.value.(x)\n # Interpret status codes for branch-and-bound\n if EAGO.local_problem_status(tstatus, pstatus) == EAGO.LRS_FEASIBLE\n opt._lower_objective_value = JuMP.objective_value(mL) \n opt._lower_solution[1:length(solution)] = solution\n opt._lower_feasibility = true\n opt._cut_add_flag = false\n else\n opt._lower_feasibility = false\n opt._lower_objective_value = -Inf\n opt._cut_add_flag = false\n end\n return\nend","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"note: Note\nBy default, EAGO solves the epigraph reformulation of your original problem, which increases the original problem dimensionality by +1 with the introduction of an auxiliary variable. When defining custom routines (such as the lower-bounding problem here) that are intended to work nicely with default EAGO routines (such as preprocessing), the user must account for the new dimensionality of the problem. In the code above, we wish to access the information of the specific B&B node and define an optimization problem based on that information. However, in this example, the node has information for 3 variables (the original 2 plus 1 for the auxiliary variable appended to the original variable vector) as (x_1 x_2 eta). The lower-bounding problem was defined to optimize the relaxed problem with respect to the original 2 decision variables. When storing the results of this subproblem to the current B&B node, it is important to take care to store the information at the appropriate indices and not inadvertently redefine the problem dimensionality (i.e., by simply storing the optimization solution as the lower_solution of the current node). For problems that are defined to only branch on a subset of the original variables, the optimizer has a member _sol_to_branch_map that carries the mapping between the indices of the original variables to those of the variables being branched on. Visit our quasiconvex example to see how this is done.","category":"page"},{"location":"examples/alpha_bb/#(Optional)-Turn-Off-Processing-Routines","page":"Advanced-Use Example 2","title":"(Optional) Turn Off Processing Routines","text":"","category":"section"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"Turn off preprocessing routines if you don't want to use them as defined in EAGO. ","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"import EAGO: preprocess!\nfunction EAGO.preprocess!(t::αBB_Convex, x::GlobalOptimizer)\n x._preprocess_feasibility = true\n return\nend","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"Turn off postprocessing routines if you don't want to use them as defined in EAGO. ","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"import EAGO: postprocess!\nfunction EAGO.postprocess!(t::αBB_Convex, x::GlobalOptimizer)\n x._postprocess_feasibility = true\n return\nend","category":"page"},{"location":"examples/alpha_bb/#Construct-the-JuMP-Model-and-Optimize","page":"Advanced-Use Example 2","title":"Construct the JuMP Model and Optimize","text":"","category":"section"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"Now, we'll tell EAGO to use our custom/extended solver, set up the main JuMP model, and solve it with our custom solver. ","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"factory = () -> EAGO.Optimizer(SubSolvers(; t = αBB_Convex() ))\nm = JuMP.Model(optimizer_with_attributes(factory,\n \"relative_tolerance\" => 1e-3,\n \"verbosity\" => 1,\n \"output_iterations\" => 1, \n \"branch_variable\" => Bool[true; true],\n ))\nQf, cf, Qg1, cg1, Qg2, cg2 = QCQP_setup() # Get QCQP data\nxL = [-3.0; -5.0] # Lower bounds on x\nxU = [1.0; 2.0] # Upper bounds on x\n@variable(m, xL[i] <= x[i=1:2] <= xU[i])\n\n# Define objective and constraints\n@objective(m, Min, 1/2*x'*Qf*x + cf'*x)\n@constraint(m, 1/2*x'*Qg1*x + cg1'*x <= 0.0)\n@constraint(m, 1/2*x'*Qg2*x + cg2'*x <= 0.0)\n\n# Solve the problem\n@time optimize!(m)","category":"page"},{"location":"examples/alpha_bb/#Retrieve-Results","page":"Advanced-Use Example 2","title":"Retrieve Results","text":"","category":"section"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"We then recover the objective value, the solution values, and termination status codes using standard JuMP syntax.","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"println(\"x1* = \", JuMP.value(x[1]), \" x2* = \",\n JuMP.value(x[2]),\" f* = \",JuMP.objective_value(m))\nTermStatus = JuMP.termination_status(m)\nPrimStatus = JuMP.primal_status(m)\nprintln(\"Algorithm terminated with a status of $TermStatus and result code of $PrimStatus\")","category":"page"},{"location":"optimizer/bnb_back/#EAGO's-Branch-and-Bound-Routine","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":"This component is meant to provide a flexible framework for implementing spatial branch-and-bound based optimization routines in Julia. All components of the branch-and-bound routine can be customized by the individual user: lower-bounding problem, upper-bounding problem.","category":"page"},{"location":"optimizer/bnb_back/#Branch-and-Bound-Node-Storage","page":"EAGO's Branch and Bound Routine","title":"Branch and Bound Node Storage","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.NodeBB","category":"page"},{"location":"optimizer/bnb_back/#EAGO.NodeBB","page":"EAGO's Branch and Bound Routine","title":"EAGO.NodeBB","text":"struct NodeBB\n\nStore information associated with each node in the branch-and-bound tree.\n\nlower_variable_bounds::Vector{Float64}: Lower bounds of variable box.\nupper_variable_bounds::Vector{Float64}: Upper bounds of variable box.\nis_integer::BitVector: Is dimension integer valued\ncontinuous::Bool: Are all dimensions continuous (or fixed)\nlower_bound::Float64: Lower bound of problem solution on nodeBB\nupper_bound::Float64: Upper bound of problem solution on nodeBB\ndepth::Int64: Depth of node in B&B tree.\ncont_depth::Int64: Depth of first parent in B&B tree that was continuously valued\nid::Int64: Unique ID for each node.\nbranch_direction::EAGO.BranchDirection: Whether last branch was negative or positive in direction\nlast_branch::Int64: Dimension of last branch\nbranch_extent::Float64: Extent of last branch (using for psuedocost calculation)\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":"The GlobalOptimizer structure holds all information relevant to branch-and-bound.","category":"page"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.GlobalOptimizer","category":"page"},{"location":"optimizer/bnb_back/#EAGO.GlobalOptimizer","page":"EAGO's Branch and Bound Routine","title":"EAGO.GlobalOptimizer","text":"mutable struct GlobalOptimizer{Q, S, T<:ExtensionType} <: MathOptInterface.AbstractOptimizer\n\nOptimizer internal to EAGO which holds information used to perform branch-and-bound in order to solve nonconvex MINLPs.\n\nDescriptions of all fields available in extended help.\n\nExtended Help\n\n_subsolvers::SubSolvers{Q, S} where {Q, S}: Storage for relaxed and upper optimizers to use, and any custom extensions\n_parameters::EAGOParameters: Parameters that do not change during a global solve\n_input_problem::InputProblem: Expressions and constraints added to the EAGO model (not directly used for relaxations)\n_working_problem::ParsedProblem: Expressions and problem descriptions that EAGO uses to formulate relaxed problems\n_auxiliary_variable_info::Union{Nothing, EAGO._AuxVarData}: Information on any auxiliary variables\nobbt_variable_values::Vector{Bool}: Variables to perform OBBT on (default: all variables in nonlinear expressions)\nenable_optimize_hook::Bool: Specifies that the optimize_hook! function should be called rather than throw the problem to the standard routine\next::Any: (Deprecated, use _subsolvers instead) Storage for custom extension types\n_end_state::EAGO.GlobalEndState: The completion status code for the branch-and-bound algorithm\n_termination_status_code::MathOptInterface.TerminationStatusCode: The MathOptInterface-compliant completion status code\n_result_status_code::MathOptInterface.ResultStatusCode: Value indicating the feasibility status of the result\n_obj_mult::Float64: Multiplier used internally to convert objective sense from Max to Min. Only takes on values of {-1.0, 1.0}\n_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!)\n_stack::DataStructures.BinaryMinMaxHeap{NodeBB}: A heap of all nodes in the branch-and-bound tree\n_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\n_first_relax_point_set::Bool: (Unused) Flag for relaxation points\n_current_xref::Vector{Float64}: (Unused) Variable values of a particular point\n_candidate_xref::Vector{Float64}: (Unused) Variable values of a candidate point\n_use_prior_objective_xref::Bool: (Unused) Flag to use variable values from previous evaluation on the current step\n_current_objective_xref::Vector{Float64}: (Unused) Variable values for objective evaluation\n_prior_objective_xref::Vector{Float64}: (Unused) Variable values for previous objective evaluation\n_user_branch_variables::Bool: Flag for if the user has specified branch variables (see label_branch_variables!)\n_fixed_variable::Vector{Bool}: Variables that are fixed in place\n_branch_variable_count::Int64: Number of variables that can be branched on\n_branch_to_sol_map::Vector{Int64}: Mapping from the branch variables to the full set of variables in the problem\n_sol_to_branch_map::Vector{Int64}: Mapping from the full set of variables in the problem to the branch variables\n_continuous_solution::Vector{Float64}: The final (or intermediate) variable values of the solution\n_preprocess_feasibility::Bool: Flag to ensure preprocessing result is feasible\n_preprocess_termination_status::MathOptInterface.TerminationStatusCode: Status codes for use in bounds tightening\n_preprocess_primal_status::MathOptInterface.ResultStatusCode: Status codes for use in bounds tightening\n_preprocess_dual_status::MathOptInterface.ResultStatusCode: Status codes for use in bounds tightening\n_lower_primal_status::MathOptInterface.ResultStatusCode: Primal status of the lower problem\n_lower_dual_status::MathOptInterface.ResultStatusCode: Dual status of the lower problem\n_lower_termination_status::MathOptInterface.TerminationStatusCode: Termination status of the lower problem\n_lower_feasibility::Bool: Flag for lower problem feasibility\n_lower_objective_value::Float64: Objective value result from the lower problem\n_lower_solution::Vector{Float64}: Variable values of the lower problem solution\n_lower_lvd::Vector{Float64}: Lower variable duals for use in duality-based bound tightening\n_lower_uvd::Vector{Float64}: Upper variable duals for use in duality-based bound tightening\n_last_cut_objective::Float64: Objective value associated with the previous cut in the cutting planes algorithm\n_upper_result_status::MathOptInterface.ResultStatusCode: Primal status of the upper problem\n_upper_termination_status::MathOptInterface.TerminationStatusCode: Termination status of the upper problem\n_upper_feasibility::Bool: Flag for upper problem feasibility\n_upper_objective_value::Float64: Objective value result from the upper problem\n_upper_variables::Vector{MathOptInterface.VariableIndex}: \n_upper_solution::Vector{Float64}: \n_postprocess_feasibility::Bool: (Unused) Flag to ensure postprocessing result is feasible\n_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!\n_start_time::Float64: Storage for the time() when optimization began\n_run_time::Float64: Current run time, incremented using time()-_start_time\n_parse_time::Float64: A field to keep track of time spent on initial problem parsing\n_presolve_time::Float64: Used in optimize_nonconvex.jl to track how long the presolve step takes\n_last_preprocess_time::Float64: Updated each iteration to track the time of the preprocess step\n_last_lower_problem_time::Float64: Updated each iteration to track the time of the lower problem step\n_last_upper_problem_time::Float64: Updated each iteration to track the time of the upper problem step\n_last_postprocessing_time::Float64: Updated each iteration to track the time of the postprocess step\n_min_converged_value::Float64: A field to track convergence progress across iterations\n_global_lower_bound::Float64: The best-known lower bound\n_global_upper_bound::Float64: The best-known upper bound\n_maximum_node_id::Int64: The total number of nodes that have been created\n_iteration_count::Int64: The number of iterations the branch-and-bound algorithm has completed\n_node_count::Int64: The number of nodes in the stack\n_solution_value::Float64: (Unused) The best-known solution value\n_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\n_solution_node::Int64: The node ID of the best-known feasible upper problem solution (default = -1, if no feasible solution is found)\n_best_upper_value::Float64: The best-known upper bound\n_obbt_working_lower_index::Vector{Bool}: Indices of variables to perform OBBT on\n_obbt_working_upper_index::Vector{Bool}: Indices of variables to perform OBBT on\n_lower_indx_diff::Vector{Bool}: Tracker for changes in obbtworkinglowerindex across iterations\n_upper_indx_diff::Vector{Bool}: Tracker for changes in obbtworkingupperindex across iterations\n_old_low_index::Vector{Bool}: Storage for indices prior to OBBT step\n_old_upp_index::Vector{Bool}: Storage for indices prior to OBBT step\n_new_low_index::Vector{Bool}: New indices following OBBT step; compared with _old_low_index\n_new_upp_index::Vector{Bool}: New indices following OBBT step; compared with _old_upp_index\n_obbt_variables::Vector{MathOptInterface.VariableIndex}: (Deprecated) Variables to perform OBBT on. Replaced by _obbt_working_lower_index and _obbt_working_upper_index\n_obbt_variable_count::Int64: The number of variables to perform OBBT on\n_obbt_performed_flag::Bool: (Unused) Flag to indicate whether OBBT has been performed\n_lower_fbbt_buffer::Vector{Float64}: Buffer for FBBT lower bounds. Set in presolve, used in preprocess\n_upper_fbbt_buffer::Vector{Float64}: Buffer for FBBT upper bounds. Set in presolve, used in preprocess\n_cp_improvement::Float64: (Unused) Improvement in constraint propagation\n_cp_evaluation_reverse::Bool: (Unused) Flag for if constraint propagation results need to be reversed\n_cut_iterations::Int64: Iterations of the cutting planes algorithm completed\n_cut_add_flag::Bool: (Unused) Flag to check if cuts should be added\n_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\n_log::Log: Storage for logging information during a branch-and-bound run\n_affine_relax_ci::Vector{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}}: Storage for affine constraints\n_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\n_relaxed_variable_number::Int64: (Unused) Number of relaxed variables\n_relaxed_variable_index::Vector{MathOptInterface.VariableIndex}: Indices of relaxed variables\n_relaxed_variable_et::Vector{Tuple{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.EqualTo{Float64}}, Int64}}: Stored EqualTo constraints\n_relaxed_variable_lt::Vector{Tuple{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}, Int64}}: Stored LessThan constraints\n_relaxed_variable_gt::Vector{Tuple{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}, Int64}}: Stored GreaterThan constraints\n_relaxed_variable_integer::Vector{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.Integer}}: Stored Integer constraints\n_branch_variables::Vector{Bool}: List of variables that can be branched on. If not user-specified, branch variables are identified in label_branch_variables!\n_nonbranching_int::Bool: (Unused) Flag for non-branching integers\n_new_eval_constraint::Bool: Flag indicating if an initial evaluation of the constraints has occurred\n_new_eval_objective::Bool: Flag indicating if the objective expression was evaluated\n_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!\n_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!\n_nonlinear_evaluator_created::Bool: Flag to check for nonlinear evaluators. Set to true in add_nonlinear_evaluator!\n_branch_cost::EAGO.BranchCostStorage{Float64}: (FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED) Storage for pseudocost branching\n_branch_variable_sparsity::SparseArrays.SparseMatrixCSC{Bool, Int64}: (FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED) Sparsity information of the branch variables\n_constraint_infeasiblity::Vector{Float64}: (FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED) Information on the infeasibility of each constraint\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#Customizable-Subroutines","page":"EAGO's Branch and Bound Routine","title":"Customizable Subroutines","text":"","category":"section"},{"location":"optimizer/bnb_back/#Stack-Management-Subroutines","page":"EAGO's Branch and Bound Routine","title":"Stack Management Subroutines","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.branch_node!(t::ExtensionType, m::GlobalOptimizer)\n EAGO.select_branch_variable(t::ExtensionType, m::GlobalOptimizer)\n EAGO.select_branch_point(t::ExtensionType, m::GlobalOptimizer, i)\n EAGO.node_selection!(t::ExtensionType, m::GlobalOptimizer)\n EAGO.fathom!(t::ExtensionType, m::GlobalOptimizer)\n EAGO.initialize_stack!(t::ExtensionType, m::GlobalOptimizer)\n EAGO.single_storage!(t::ExtensionType, m::GlobalOptimizer)","category":"page"},{"location":"optimizer/bnb_back/#EAGO.branch_node!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.branch_node!","text":"branch_node!(t::ExtensionType, m::GlobalOptimizer)\n\n\nCreate two nodes from current_node and store them on the stack. Call select_branch_variable(t, m) and select_branch_point(t, m, k) to determine the variable that should be branched on and the point at which branching should occur, respectively.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.select_branch_variable-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.select_branch_variable","text":"select_branch_variable(\n t::ExtensionType,\n m::GlobalOptimizer\n) -> Any\n\n\nChoose a variable to branch on. A maximum relative width branching rule is used by default.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.select_branch_point-Tuple{ExtensionType, GlobalOptimizer, Any}","page":"EAGO's Branch and Bound Routine","title":"EAGO.select_branch_point","text":"select_branch_point(\n t::ExtensionType,\n m::GlobalOptimizer,\n i\n) -> Float64\n\n\nSelect a point xb within the domain of the ith branching variable. By default, this point is a convex combination of the solution to the relaxation and the midpoint of the node (branch_cvx_factor*xmid + (1-branch_cvx_factor)*xsol). If the solution lies within branch_offset of a bound, then the branch point is moved to a distance of branch_offset from that bound.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.node_selection!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.node_selection!","text":"node_selection!(t::ExtensionType, m::GlobalOptimizer)\n\n\nSelect the next node in the stack to evaluate. By default, perform best-first node selection (select the node with the lowest lower bound in the stack).\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.fathom!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.fathom!","text":"fathom!(t::ExtensionType, m::GlobalOptimizer)\n\n\nRemove nodes from the stack. By default, delete nodes from the stack if their lower bounds are greater than the current global upper bound.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.initialize_stack!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.initialize_stack!","text":"initialize_stack!(t::ExtensionType, m::GlobalOptimizer)\n\n\nPrepare the stack for the branch-and-bound routine. By default, create an initial node with the variable bounds as box constraints and add it to the stack.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.single_storage!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.single_storage!","text":"single_storage!(t::ExtensionType, m::GlobalOptimizer)\n\n\nStore the current node to the stack, without branching, after updating lower/upper bounds.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#Internal-Subproblem-Status-Codes-and-Subsolver-Management","page":"EAGO's Branch and Bound Routine","title":"Internal Subproblem Status Codes and Subsolver Management","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.RelaxResultStatus\n EAGO.LocalResultStatus\n EAGO.Incremental\n EAGO.SubSolvers\n EAGO.set_default_config!(t::ExtensionType, m::GlobalOptimizer)","category":"page"},{"location":"optimizer/bnb_back/#EAGO.RelaxResultStatus","page":"EAGO's Branch and Bound Routine","title":"EAGO.RelaxResultStatus","text":"RelaxResultStatus\n\nStatus code used internally to determine how to interpret the results from the solution of a relaxed problem.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.LocalResultStatus","page":"EAGO's Branch and Bound Routine","title":"EAGO.LocalResultStatus","text":"LocalResultStatus\n\nStatus code used internally to determine how to interpret the results from the solution of a local problem solve.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.Incremental","page":"EAGO's Branch and Bound Routine","title":"EAGO.Incremental","text":"mutable struct Incremental{S<:MathOptInterface.AbstractOptimizer} <: MathOptInterface.AbstractOptimizer\n\nA 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. \n\n(Deprecated) For Q = Val{true}, the subsolver supports incremental loading. For Q = Val{false}, the subsolver does not.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.SubSolvers","page":"EAGO's Branch and Bound Routine","title":"EAGO.SubSolvers","text":"mutable struct SubSolvers{Q<:MathOptInterface.AbstractOptimizer, S<:MathOptInterface.AbstractOptimizer, T<:ExtensionType}\n\nA structure containing the relaxed and upper optimizers to be used, as well as any user-defined extension.\n\nrelaxed_optimizer::MathOptInterface.AbstractOptimizer: Optimizer used to solve relaxed subproblems. Set using r = [...] (<: MOI.AbstractOptimizer) (default = Cbc.Optimizer())\nupper_optimizer::MathOptInterface.AbstractOptimizer: Optimizer used to solve upper bounding problems. Set using u = [...] (<: MOI.AbstractOptimizer) (default = Ipopt.Optimizer())\next::ExtensionType: User-defined extension to use. Set using t = [...](<: EAGO.ExtensionType)\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.set_default_config!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.set_default_config!","text":"set_default_config!\n\nConfigures subsolver tolerances based on tolerance parameters provided to EAGO (provided that a specialized subsolver configuration routine has been provided and m.user_solver_config = false).\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#Main-Subproblem-and-Termination-Subroutines","page":"EAGO's Branch and Bound Routine","title":"Main Subproblem and Termination Subroutines","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.convergence_check(t::ExtensionType, m::GlobalOptimizer)\n EAGO.cut_condition(t::ExtensionType, m::GlobalOptimizer)\n EAGO.lower_problem!(t::ExtensionType, m::GlobalOptimizer{R,S,Q}) where {R,S,Q<:ExtensionType}\n EAGO.preprocess!(t::ExtensionType, m::GlobalOptimizer{R,S,Q}) where {R,S,Q<:ExtensionType}\n EAGO.postprocess!(t::ExtensionType, m::GlobalOptimizer)\n EAGO.repeat_check(t::ExtensionType, m::GlobalOptimizer)\n EAGO.termination_check(t::ExtensionType, m::GlobalOptimizer)\n EAGO.upper_problem!(t::ExtensionType, m::GlobalOptimizer)\n EAGO.parse_global!(t::ExtensionType, m::GlobalOptimizer)\n EAGO.optimize_hook!(t::ExtensionType, m::Optimizer)","category":"page"},{"location":"optimizer/bnb_back/#EAGO.convergence_check-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.convergence_check","text":"convergence_check(\n t::ExtensionType,\n m::GlobalOptimizer\n) -> Bool\n\n\nCheck for problem convergence.\n\nBy default, check if the lower and upper bounds have converged to within absolute and/or relative tolerances.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.cut_condition-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.cut_condition","text":"cut_condition(t::ExtensionType, m::GlobalOptimizer) -> Bool\n\n\nReturns true if a cut should be added and computes a new reference point to add the cut at. By default, checks that cut_max_iterations are not exceeded and that the improvement in the objective value associated with the previous cut is greater than both an absolute tolerance cut_ϵ_abs and a relative tolerance cut_ϵ_rel. Returns false otherwise.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.lower_problem!-Union{Tuple{Q}, Tuple{S}, Tuple{R}, Tuple{ExtensionType, GlobalOptimizer{R, S, Q}}} where {R, S, Q<:ExtensionType}","page":"EAGO's Branch and Bound Routine","title":"EAGO.lower_problem!","text":"lower_problem!(\n t::ExtensionType,\n m::GlobalOptimizer{R, S, Q<:ExtensionType}\n)\n\n\nConstructs a relaxation of the MINLP on node y and solves it using the default EAGO relaxation scheme. By default, EAGO applies Kelley's algorithm (from Kelley Jr., J.E.: The cutting-plane method for solving convex programs. J. Soc. Ind. Appl. Math. 8(4), 703 to 712 (1960)) while cut_condition(m) returns true then activates the integrality constraints of the relaxed problems and solves the resulting MILP relaxation. results are stored to the _lower_solution, _lower_termination_status, _lower_primal_status, _lower_dual_status, _lower_objective_value, and _lower_feasibility. Further, lower and upper variable duals are stored _lower_lvd and _lower_uvd, respectively, for use in duality based bound tightening. If relaxation-based bounds are weaker or cutting-planes are numerically poorly ill-posed, then interval bounds are used instead. If the problem is dual feasible but the primal status is ambiguous the dual objective value is used for the lower bound to avoid numerical issues.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.preprocess!-Union{Tuple{Q}, Tuple{S}, Tuple{R}, Tuple{ExtensionType, GlobalOptimizer{R, S, Q}}} where {R, S, Q<:ExtensionType}","page":"EAGO's Branch and Bound Routine","title":"EAGO.preprocess!","text":"preprocess!(\n t::ExtensionType,\n m::GlobalOptimizer{R, S, Q<:ExtensionType}\n)\n\n\nRuns contractor methods prior to solving lower bounding problem. By default linear and quadratic contractor methods followed by interval constraint propagation then optimization-based bound tightening for a specified number of iterations while the subproblem at current node n has not been proven infeasible.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.postprocess!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.postprocess!","text":"postprocess!(t::ExtensionType, m::GlobalOptimizer)\n\n\nDefault postprocess perfoms duality-based bound tightening (Tawarmalani, M., Sahinidis, N.V.: Global optimization of mixed-integer nonlinear programs: a theoretical and computational study. Math. Progr. 99, 563–591 (2004).) up to an iteration limit set by dbbt_depth.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.repeat_check-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.repeat_check","text":"repeat_check(t::ExtensionType, m::GlobalOptimizer) -> Bool\n\n\nCheck to see if current node should be reprocessed. Without any custom extension, return false by default.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.termination_check-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.termination_check","text":"termination_check(m::GlobalOptimizer)\ntermination_check(t::ExtensionType, m::GlobalOptimizer) -> Bool\n\nCheck for termination of the branch-and-bound algorithm.\n\nIf only the GlobalOptimizer is given as an argument, termination_check dispatches to the other form using the ExtensionType given in the SubSolvers. If there is no user-defined extension, then by default, this will check for satisfaction of absolute or relative tolerances, solution infeasibility, and other specified limits. Returns true if any conditions are met and branch-and-bound should end, and false otherwise.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.upper_problem!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.upper_problem!","text":"upper_problem!(t::ExtensionType, m::GlobalOptimizer)\n\n\nDefault upper bounding problem which simply calls solve_local_nlp! to solve the NLP locally.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.parse_global!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.parse_global!","text":"Basic parsing for global solutions (no extensive manipulation). By default, does nothing.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.optimize_hook!-Tuple{ExtensionType, Optimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.optimize_hook!","text":"optimize_hook!(t::ExtensionType, m::Optimizer)\n\nProvide a hook for extensions to EAGO. \n\nThe user-defined extension of optimize_hook! is used in EAGO's overloading of MOI.optimize! (see EAGO.jl/src/eago_optimizer/optimize/optimize.jl). Without the optimize_hook! specified, EAGO will run initial_parse!, parse_classify_problem!, and then optimize! using the parsed problem type. The user-specified optimize_hook! should thus take the new extension and Optimizer as inputs and will execute when the user writes optimize!(model).\n\nExample\n\nHere, optimize_hook! is used to bypass EAGO's problem parsing and treat every problem using its branch-and-bound routine. This is done in this example by telling EAGO to treat the problem as a mixed integer nonconvex problem, which normally dispatches to branch-and-bound.\n\nstruct MyNewExtension <: EAGO.ExtensionType end\nimport EAGO: optimize_hook!\nfunction EAGO.optimize_hook!(t::MyNewExtension, m::Optimizer)\n initial_parse!(m)\n optimize!(EAGO.MINCVX(), m)\nend\n\nThe same functionality could be accomplished by setting the EAGOParameter field force_global_solve to be true.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#Internal-Subroutines","page":"EAGO's Branch and Bound Routine","title":"Internal Subroutines","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.is_integer_subproblem(m)\n EAGO.is_integer_feasible_local(m::GlobalOptimizer, d)\n EAGO.is_integer_feasible_relaxed(m::GlobalOptimizer)\n EAGO.interval_bound\n EAGO.lower_interval_bound\n EAGO.same_box(x::NodeBB,y::NodeBB, atol::Float64)\n EAGO.solve_local_nlp!(x::Optimizer)\n EAGO.set_dual!(x::Optimizer)\n EAGO.update_relaxed_problem_box!\n EAGO.reform_epigraph_min!(m::GlobalOptimizer)\n EAGO.label_fixed_variables!(m::GlobalOptimizer)\n EAGO.label_branch_variables!(m::GlobalOptimizer)\n EAGO.add_nonlinear!(m::GlobalOptimizer)\n EAGO.parse_classify_problem!(m::GlobalOptimizer)\n EAGO.local_problem_status(t::MathOptInterface.TerminationStatusCode, r::MathOptInterface.ResultStatusCode)","category":"page"},{"location":"optimizer/bnb_back/#EAGO.is_integer_subproblem-Tuple{Any}","page":"EAGO's Branch and Bound Routine","title":"EAGO.is_integer_subproblem","text":"is_integer_subproblem(m)\n\n\nReturns true that the subproblem at the current node n has participating integer variables that have not been fixed to constant valued as the branch-and-bound algorithm progresses. Returns false otherwise.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.is_integer_feasible_local-Tuple{GlobalOptimizer, Any}","page":"EAGO's Branch and Bound Routine","title":"EAGO.is_integer_feasible_local","text":"is_integer_feasible_local(m::GlobalOptimizer, d) -> Bool\n\n\nChecks that the solution of a local solve is integer feasible to within the tolerances specified by integer_abs_tol and integer_rel_tol.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.is_integer_feasible_relaxed-Tuple{GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.is_integer_feasible_relaxed","text":"is_integer_feasible_relaxed(m::GlobalOptimizer) -> Bool\n\n\nCheck that the solution of the lower (relaxed problem) is integer feasible to within tolerances specified by the parameters: integer_abs_tol (absolute tolerance) and integer_rel_tol (relative tolerance).\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.interval_bound","page":"EAGO's Branch and Bound Routine","title":"EAGO.interval_bound","text":"interval_bound(::GlobalOptimizer, ::T)\n\nCompute a tuple representing the lower and upper interval bounds for an AbstractEAGOConstraint representing an equality constraint.\n\nOptions for T (all are subtypes of AbstractEAGOConstraint):\n\nAffineFunctionEq\nAffineFunctionIneq\nBufferedQuadraticEq\nBufferedQuadraticIneq\nBufferedNonlinearFunction{V,N,T} where {V,N,T}\n\n\n\n\n\n","category":"function"},{"location":"optimizer/bnb_back/#EAGO.lower_interval_bound","page":"EAGO's Branch and Bound Routine","title":"EAGO.lower_interval_bound","text":"lower_interval_bound(::GlobalOptimizer, ::T)\n\nCompute the lower interval bound for an AbstractEAGOConstraint representing an inequality constraint.\n\nOptions for T (all are subtypes of AbstractEAGOConstraint):\n\nAffineFunctionIneq\nBufferedQuadraticIneq\nBufferedSOC\nBufferedNonlinearFunction{V,N,T} where {V,N,T}\n\n\n\n\n\n","category":"function"},{"location":"optimizer/bnb_back/#EAGO.same_box-Tuple{NodeBB, NodeBB, Float64}","page":"EAGO's Branch and Bound Routine","title":"EAGO.same_box","text":"same_box(x::NodeBB, y::NodeBB, r::Float64) -> Bool\n\n\nCheck that node x and y have equal domains within an absolute tolerance of r.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.solve_local_nlp!-Tuple{Optimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.solve_local_nlp!","text":"Constructs and solves the problem locally on node y updated the upper solution informaton in the optimizer.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.set_dual!-Tuple{Optimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.set_dual!","text":"set_dual!(m)\n\n\nRetrieves the lower and upper duals for variable bounds from the relaxed_optimizer and sets the appropriate values in the _lower_lvd and _lower_uvd storage fields.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.update_relaxed_problem_box!","page":"EAGO's Branch and Bound Routine","title":"EAGO.update_relaxed_problem_box!","text":"update_relaxed_problem_box!(m)\n\n\nUpdate the relaxed constraint by setting the constraint set of v == x* , xL_i <= x_i, and x_i <= xU_i for each such constraint added to the relaxed optimizer. Resets integral valued constraints to either EqualTo or Interval constraints.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/bnb_back/#EAGO.reform_epigraph_min!-Tuple{GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.reform_epigraph_min!","text":"reform_epigraph_min!(m::GlobalOptimizer)\n\n\nPerform an epigraph reformulation assuming the working_problem is a minimization problem.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.label_fixed_variables!-Tuple{GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.label_fixed_variables!","text":"label_fixed_variables!(m::GlobalOptimizer) -> Vector{Bool}\n\n\nDetect any variables set to a fixed value by equality or inequality constraints and populate the _fixed_variable storage array.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.label_branch_variables!-Tuple{GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.label_branch_variables!","text":"label_branch_variables!(m::GlobalOptimizer)\n\n\nDetect any variables participating in nonconvex terms and populate the _branch_variables storage array.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.add_nonlinear!-Tuple{GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.add_nonlinear!","text":"add_nonlinear!(m::GlobalOptimizer)\n\n\nAdd an Evaluator and nonlinear functions and populate each appropriately.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.parse_classify_problem!-Tuple{GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.parse_classify_problem!","text":"parse_classify_problem!(m::GlobalOptimizer)\n\nInterprets the type/number of constraints and the type of objective function to infer a problem type. Current possible types include:\n\nLP: Linear program; sent to optimize_lp.jl\n'MILP: Mixed integer linear program; sent tooptimize_lp.jl`\nSOCP: Second-order cone program; sent to optimize_conic.jl\nMINCVX: Mixed-integer nonconvex; sent to optimize_nonconvex.jl\n\nIf the force_global_solve parameter is set to true, parse_classify_problem! will set the problem type to MINCVX to pass the problem to optimize_nonconvex.jl.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.local_problem_status-Tuple{MathOptInterface.TerminationStatusCode, MathOptInterface.ResultStatusCode}","page":"EAGO's Branch and Bound Routine","title":"EAGO.local_problem_status","text":"local_problem_status(t, r)\n\n\nTakes an MOI.TerminationStatusCode and a MOI.ResultStatusCode and returns true if this corresponds to a solution that is proven to be feasible. Returns false otherwise.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#Functions-for-Generating-Console-Output","page":"EAGO's Branch and Bound Routine","title":"Functions for Generating Console Output","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.print_iteration!\n EAGO.print_node!\n EAGO.print_results!\n EAGO.print_solution!","category":"page"},{"location":"optimizer/bnb_back/#EAGO.print_iteration!","page":"EAGO's Branch and Bound Routine","title":"EAGO.print_iteration!","text":"print_iteration!\n\nPrint status information based on iteration count. The header print frequency is based on the header_iterations setting, and the data print frequency is based on the output_iterations setting.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/bnb_back/#EAGO.print_node!","page":"EAGO's Branch and Bound Routine","title":"EAGO.print_node!","text":"print_node!\n\nPrint information about the current node. Includes node ID, lower bound, upper bound, and interval box.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/bnb_back/#EAGO.print_results!","page":"EAGO's Branch and Bound Routine","title":"EAGO.print_results!","text":"print_results!(m::GlobalOptimizer, lower_flag::Bool)\n\n\nPrint the results of a single (lower or upper) bounding problem. lower_flag=true prints information for the lower problem, lower_flag=false prints information for the upper problem.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/bnb_back/#EAGO.print_solution!","page":"EAGO's Branch and Bound Routine","title":"EAGO.print_solution!","text":"print_solution!\n\nPrint solution information for the B&B problem. Display node with the best solution, solution value, solution, and time spent solving subproblems. This print occurs following termination of the B&B algorithm.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/bnb_back/#Support-for-Log-Output-at-Each-Iteration","page":"EAGO's Branch and Bound Routine","title":"Support for Log Output at Each Iteration","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.Log\n EAGO.log_iteration!(x::GlobalOptimizer)","category":"page"},{"location":"optimizer/bnb_back/#EAGO.Log","page":"EAGO's Branch and Bound Routine","title":"EAGO.Log","text":"mutable struct Log\n\nA structure used to store information on the history of the solution procedure for generating convergence plots and other analyses.\n\ncurrent_lower_bound::Vector{Float64}: Storage for lower bound calculated for current node.\ncurrent_upper_bound::Vector{Float64}: Storage for upper bound calculated for current node.\npreprocessing_time::Vector{Float64}: Storage for preprocessing time of each iteration.\nlower_problem_time::Vector{Float64}: Storage for lower bounding time of each iteration.\nupper_problem_time::Vector{Float64}: Storage for upper bounding time of each iteration.\npostprocessing_time::Vector{Float64}: Storage for postprocessing time of each iteration.\npreprocessing_feas::Vector{Bool}: Storage for preprocessing feasibility of each iteration.\nlower_problem_feas::Vector{Bool}: Storage for lower bounding feasibility of each iteration.\nupper_problem_feas::Vector{Bool}: Storage for upper bounding feasibility of each iteration.\npostprocessing_feas::Vector{Bool}: Storage for postprocessing feasibility of each iteration.\nglobal_lower_bound::Vector{Float64}: Storage for best (global) lower bound at each iteration.\nglobal_upper_bound::Vector{Float64}: Storage for best (global) upper bound at each iteration.\nnode_count::Vector{Int64}: Number of nodes at each iteration.\nrun_time::Vector{Float64}: Run time at each iteration.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.log_iteration!-Tuple{GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.log_iteration!","text":"log_iteration!(m::GlobalOptimizer)\n\n\nIf log_on is true, the global_lower_bound, global_upper_bound, run_time, and node_count are stored every log_interval. If log_subproblem_info then the lower bound, feasibility and run times of the subproblems are logged every log_interval.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#Interval-Representations-of-Expressions","page":"EAGO's Branch and Bound Routine","title":"Interval Representations of Expressions","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.AbstractEAGOConstraint\n EAGO.AffineFunctionEq\n EAGO.AffineFunctionIneq\n EAGO.BufferedQuadraticIneq\n EAGO.BufferedQuadraticEq\n EAGO.NonlinearExpression\n EAGO.BufferedNonlinearFunction","category":"page"},{"location":"optimizer/bnb_back/#EAGO.AbstractEAGOConstraint","page":"EAGO's Branch and Bound Routine","title":"EAGO.AbstractEAGOConstraint","text":"abstract type AbstractEAGOConstraint\n\nAn abstract super-type used for representing constraints built by EAGO's backend.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.AffineFunctionEq","page":"EAGO's Branch and Bound Routine","title":"EAGO.AffineFunctionEq","text":"mutable struct AffineFunctionEq <: EAGO.AbstractEAGOConstraint\n\nRepresentation of an affine equality. Currently only used for bound tightening.\n\nterms::Vector{Tuple{Float64, Int64}}\nconstant::Float64\nlen::Int64\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.AffineFunctionIneq","page":"EAGO's Branch and Bound Routine","title":"EAGO.AffineFunctionIneq","text":"mutable struct AffineFunctionIneq <: EAGO.AbstractEAGOConstraint\n\nRepresentation of an affine inequality. Currently only used for bound tightening.\n\nterms::Vector{Tuple{Float64, Int64}}\nconstant::Float64\nlen::Int64\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.BufferedQuadraticIneq","page":"EAGO's Branch and Bound Routine","title":"EAGO.BufferedQuadraticIneq","text":"mutable struct BufferedQuadraticIneq <: EAGO.AbstractEAGOConstraint\n\nRepresentation of a general quadratic inequality constraint with a buffer.\n\nfunc::MathOptInterface.ScalarQuadraticFunction{Float64}\nbuffer::Dict{Int64, Float64}\nsaf::MathOptInterface.ScalarAffineFunction{Float64}\nlen::Int64\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.BufferedQuadraticEq","page":"EAGO's Branch and Bound Routine","title":"EAGO.BufferedQuadraticEq","text":"mutable struct BufferedQuadraticEq <: EAGO.AbstractEAGOConstraint\n\nRepresentation of a general quadratic equality constraint with a buffer.\n\nfunc::MathOptInterface.ScalarQuadraticFunction{Float64}\nminus_func::MathOptInterface.ScalarQuadraticFunction{Float64}\nbuffer::Dict{Int64, Float64}\nsaf::MathOptInterface.ScalarAffineFunction{Float64}\nlen::Int64\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.NonlinearExpression","page":"EAGO's Branch and Bound Routine","title":"EAGO.NonlinearExpression","text":"mutable struct NonlinearExpression{V, N, T<:RelaxTag} <: EAGO.AbstractEAGOConstraint\n\nStores a general quadratic function with a buffer.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.BufferedNonlinearFunction","page":"EAGO's Branch and Bound Routine","title":"EAGO.BufferedNonlinearFunction","text":"mutable struct BufferedNonlinearFunction{V, N, T<:RelaxTag} <: EAGO.AbstractEAGOConstraint\n\nStores a general nonlinear function with a buffer represented by the sum of a tape and a scalar affine function.\n\n\n\n\n\n","category":"type"},{"location":"custom_guidelines/#Customization-Guidelines","page":"Customization","title":"Customization Guidelines","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"This section contains general guidelines on how the functionality of EAGO can be extended for specific use cases. Many functions in EAGO are extensible, so examples are not provided for every possible case, but some important functions are covered. If there is a use case you do not see provided here, but would like to see, please contact Robert Gottlieb.","category":"page"},{"location":"custom_guidelines/#)-Creating-an-Extension","page":"Customization","title":"1) Creating an Extension","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"Extensibility in EAGO is based on the ExtensionType. To create customized functions, the recommended method is to create a new structure, as follows:","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"using EAGO\n\nstruct MyNewStruct <: EAGO.ExtensionType end","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"To let EAGO know that you would like to use this extension (and any functions you overload), when you create the JuMP model, declare your new type in the subsolver_block field of the Optimizer as follows:","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"using JuMP\n\nfactory = () -> EAGO.Optimizer(SubSolvers(; t = MyNewStruct() ))\nmodel = Model(factory)","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"The key point to note here is that the new structure is set to SubSolvers.t, which is the field that holds any user-defined extension type. Now, when EAGO calls any of its functions, it will check to see if a custom function for this new extension has been created. If so, it will use the new one; if not, it will use the default version of that function.","category":"page"},{"location":"custom_guidelines/#)-Preprocessing","page":"Customization","title":"2) Preprocessing","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"In EAGO's branch-and-bound routine, preprocessing is performed prior to solving the lower and upper problems. By default, linear and quadratic contractor methods are performed, followed by interval constraint propagation, then optimization-based bounds tightening. An important outcome of EAGO's default preprocessing is that the _preprocess_feasibility field of the GlobalOptimizer is set to true, unless the subproblem at the current node has been proven infeasible. Therefore, to bypass preprocessing for your own problem, you must, at a minimum, set this field to true. For example:","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"import EAGO: preprocess!\nfunction EAGO.preprocess!(t::MyNewStruct, x::EAGO.GlobalOptimizer)\n x._preprocess_feasibility = true\nend","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"The user-defined preprocessing step can be as simple or complex as desired, but if _preprocess_feasibility is not set to true, EAGO will assume each node is infeasible.","category":"page"},{"location":"custom_guidelines/#)-Lower-Problem","page":"Customization","title":"3) Lower Problem","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"By default, EAGO applies Kelley's cutting-plane algorithm [1] to solve the lower-problem. This can be overloaded using the same syntax as for the other functions. Necessary changes to the GlobalOptimizer that occur within the lower problem are changing the _lower_objective_value and _lower_feasibility fields. If the _lower_objective_value field is not changed, branch-and-bound will not update the lower bound. If _lower_feasibility is not set to true, the node will be discarded as infeasible. A minimum functional (though not useful) lower problem extension is as follows:","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"import EAGO: lower_problem!\nfunction EAGO.lower_problem!(t::MyNewStruct, x::EAGO.GlobalOptimizer)\n x._lower_objective_value = -Inf\n x._lower_feasibility = true\nend","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"Any arbitrarily complex lower problem can be substituted here in place of EAGO's default method, as long as these fields are updated. Note also that, although there is a separate upper problem function, if the lower problem is being replaced by an algorithm that also calculates an upper objective value, the necessary fields to update in upper_problem! can simply be updated here, and the upper_problem! can be overloaded by a function that does nothing.","category":"page"},{"location":"custom_guidelines/#)-Upper-Problem","page":"Customization","title":"4) Upper Problem","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"By default, the upper-bounding problem is run on every node up to depth upper_bounding_depth, and is triggered with a probability of 0.5^(depth - upper_bounding_depth) afterwards for continuous problems. For integer problems, this approach is used in addition to running on every node up to depth upper_bounding_depth + cont_depth, with another trigger of probability 0.5^(depth - upper_bounding_depth - cont_depth). The upper_bounding_depth and cont_depth are fields of EAGOParameters and can be changed from their default values when the JuMP model is created, or at any time afterwards. If any of these trigger conditions are met, the default EAGO upper problem runs a local NLP solve. ","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"The important fields to update in the upper_problem! are the _upper_objective_value and _upper_feasibility fields. If _upper_objective_value is not updated, the upper bound in the branch-and-bound algorithm will not update and the problem will not converge. If _upper_feasibility is not set to true, then any changes made to _upper_objective_value will not be updated for each node and the problem will not converge. A minimum functional (though not useful) upper problem extension is as follows:","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"import EAGO: upper_problem!\nfunction upper_problem!(t::MyNewStruct, x::EAGO.GlobalOptimizer)\n x._upper_objective_value = Inf\n x._upper_feasibility = true\nend","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"This example upper problem will set the upper bound on the objective value to Inf for each node. Given that no useful information is provided here, we could also have set x_upper_feasibility to false (or equivalently, remove the line where we set it to true), and the global upper bound would never be updated.","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"Note that if the _upper_objective_value is changed elsewhere, such as in the definition for the lower_problem!, the _upper_feasibility flag must be set to true. If this is not done, the change to the _upper_objective_value will be discarded.","category":"page"},{"location":"custom_guidelines/#)-Convergence-Check","page":"Customization","title":"5) Convergence Check","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"By default, EAGO checks to see if the lower and upper bounds have converged to within either the absolute or relative tolerance. This method of checking convergence may not be desired if, for example, only the absolute tolerance is relevant, and you want to ensure that the program does not end prematurely due to a relative tolerance limit being reached. The fields to check are _lower_objective_value and _upper_objective_value for the best-identified global lower and upper bounds, respectively. This function should return true if the lower and upper bounds have converged, and false otherwise. An example of how to specify that the convergence check only use the absolute tolerance is as follows:","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"import EAGO: convergence_check\nfunction EAGO.convergence_check(t::MyNewStruct, x::EAGO.GlobalOptimizer)\n gap = (x._upper_objective_value - x._lower_objective_value)\n return (gap <= x._parameters.absolute_tolerance)\nend","category":"page"},{"location":"custom_guidelines/#)-Postprocessing","page":"Customization","title":"6) Postprocessing","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"Postprocessing is the final step before a node is branched on. By default, EAGO performs duality-based bounds tightening [2] up to an iteration limit set by dbbt_depth in the EAGOParameters field. The important field to update in postprocessing is _postprocess_feasibility, which must be set to true for EAGO to branch on any given node. The minimum working postprocessing function is therefore:","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"import EAGO: postprocess!\nfunction EAGO.postprocess!(t::MyNewStruct, x::EAGO.GlobalOptimizer)\n x._postprocess_feasibility = true\nend","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"If _postprocess_feasibility is not set to true, no nodes will be branched on.","category":"page"},{"location":"custom_guidelines/#)-Termination-Check","page":"Customization","title":"7) Termination Check","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"This is the check that occurs on each iteration of the branch-and-bound algorithm that determines whether the algorithm continues or not. By default, several conditions are checked for such as the satisfaction of absolute or relative tolerances, solution infeasibility, or other specified limits. This function returns true if any of the stopping conditions have been met, and branch-and-bound should stop, and false otherwise. The important fields to update are _end_state, which takes values of EAGO.GlobalEndState, _termination_status_code, which takes values of MOI.TerminationStatusCode, and _result_status_code, which takes values of MOI.ResultStatusCode. Combined, these fields provide information about the branch-and-bound completion status and result feasibility. ","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"As an example, suppose we have updated the convergence_check function to only check for absolute tolerance, and based on our knowledge of the problem, this is the only condition we care about, and we know the solution will be optimal. We could then overload the termination_check function as follows:","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"import EAGO: termination_check\nfunction EAGO.termination_check(t::MyNewStruct, x::EAGO.GlobalOptimizer)\n flag = EAGO.convergence_check(t, x)\n if flag\n x._end_state = EAGO.GS_OPTIMAL\n x._termination_status_code = MathOptInterface.OPTIMAL\n x._result_status_code = MathOptInterface.FEASIBLE_POINT\n end\n return flag\nend","category":"page"},{"location":"custom_guidelines/#References","page":"Customization","title":"References","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"Kelley, J. E. “The Cutting-Plane Method for Solving Convex Programs.” Journal of the Society for Industrial and Applied Mathematics, vol. 8, no. 4, pp. 703–12 (1960). \nTawarmalani, M., Sahinidis, N. V. \"Global optimization of mixed-integer nonlinear programs: A theoretical and computational study.\" Math. Program., Ser. A, 99, pp. 563-591 (2004).","category":"page"},{"location":"optimizer/high_performance/#High-Performance-Configuration","page":"High-Performance Configuration","title":"High-Performance Configuration","text":"","category":"section"},{"location":"optimizer/high_performance/#Linear-Programming-Solver-Selection","page":"High-Performance Configuration","title":"Linear Programming Solver Selection","text":"","category":"section"},{"location":"optimizer/high_performance/","page":"High-Performance Configuration","title":"High-Performance Configuration","text":"By default, EAGO uses GLPK for solving linear subproblems introduced. Using a commercial linear programming (LP) solver is highly recommended, such as Gurobi, CPLEX, or XPRESS. Both Gurobi and CPLEX are free for academics and installation information can be found on the Gurobi website and the IBM website, respectively.","category":"page"},{"location":"optimizer/high_performance/","page":"High-Performance Configuration","title":"High-Performance Configuration","text":"A non-default LP solver can then be selected by the user via a series of keyword argument inputs as illustrated in the code snippet below. The relaxed_optimizer contains an instance optimizer with valid relaxations that are made at the root node and is updated with affine relaxations in place.","category":"page"},{"location":"optimizer/high_performance/","page":"High-Performance Configuration","title":"High-Performance Configuration","text":"# Create opt EAGO Optimizer with Gurobi as a lower subsolver\neago_factory = () -> EAGO.Optimizer(SubSolvers(; r = Gurobi.Optimizer()))\nm = Model(eago_factory)","category":"page"},{"location":"optimizer/high_performance/#Rounding-Mode","page":"High-Performance Configuration","title":"Rounding Mode","text":"","category":"section"},{"location":"optimizer/high_performance/","page":"High-Performance Configuration","title":"High-Performance Configuration","text":"The IntervalArithmetic.jl package supports a number of different directed rounding modes. The default directed rounding mode is :tight. It is recommended that the user specify that :accurate directed rounding mode be used as it may results in a significant performance improvement. Setting a rounding mode can requires the redefinition of a number of functions. As a result, this should only be done at the top-level by the user (rather than by using keyword arguments). To set the rounding mode to :accurate using the following syntax when loading the EAGO package initially:","category":"page"},{"location":"optimizer/high_performance/","page":"High-Performance Configuration","title":"High-Performance Configuration","text":"using IntervalArithmetic; setrounding(Interval, :accurate)\nusing EAGO\n# REST OF CODE","category":"page"},{"location":"optimizer/high_performance/#Ipopt-Build","page":"High-Performance Configuration","title":"Ipopt Build","text":"","category":"section"},{"location":"optimizer/high_performance/","page":"High-Performance Configuration","title":"High-Performance Configuration","text":"Ipopt is the recommended solver for upper-bounding problems. Ipopt's performance is highly dependent on the linear algebra package used (up to 30x). By default MUMPS is used. It is recommended that you either compile Ipopt with HSL MA57 or the Pardiso linear algebra packages with a machine specific Blas library (for Intel users the JuliaPro MKL version is recommended). For information on this, see the links below:","category":"page"},{"location":"optimizer/high_performance/","page":"High-Performance Configuration","title":"High-Performance Configuration","text":"Compiling Ipopt\nJulia specifics:\nPointing Ipopt to a compiled version:\nIpopt Package Info\nDiscourse discussion\nIssues using Pardiso:\nUbuntu\nWindows\nHSL website\nPardiso website","category":"page"},{"location":"dev/future/#Future-Work","page":"Future Work","title":"Future Work","text":"","category":"section"},{"location":"dev/future/#Current-Activity","page":"Future Work","title":"Current Activity","text":"","category":"section"},{"location":"dev/future/","page":"Future Work","title":"Future Work","text":"Update CI testing.\nSpecialized algorithms for relaxing ODE constrained problems and solving global and robust optimization problems.\nExtensions for nonconvex dynamic global & robust optimization.\nProvide support for mixed-integer problems.\nUpdate EAGO to support nonsmooth problems (requires: a nonsmooth local nlp optimizer or lexicographic AD, support for relaxations is already included).\nEvaluation and incorporation of implicit relaxation routines in basic solver.","category":"page"},{"location":"dev/future/#Other-Things-on-the-Wishlist-(But-Not-Actively-Being-Worked-On)","page":"Future Work","title":"Other Things on the Wishlist (But Not Actively Being Worked On)","text":"","category":"section"},{"location":"dev/future/","page":"Future Work","title":"Future Work","text":"Implement the interval constraint propagation scheme presented in Vu 2008. For improved convergences.\nA parametric bisection routine will be updated that can divide the (X P) space into a series of boxes that all contain unique branches of the implicit function p - y(p).\nProvide a better interface the nonconvex semi-infinite programs solvers (JuMPeR extension?).\nAdd additional McCormick relaxations.\nAdd handling for domain reduction of special expression forms.","category":"page"},{"location":"examples/explicit_ann/#Standard-Use-Example-1","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"","category":"section"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"This example is also provided here as a Jupyter Notebook.","category":"page"},{"location":"examples/explicit_ann/#Solving-an-ANN-to-Optimality-in-EAGO","page":"Standard-Use Example 1","title":"Solving an ANN to Optimality in EAGO","text":"","category":"section"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"In [1, 2], a surrogate artificial neural network (ANN) model of bioreactor productivity was constructed by fitting results from computationally expensive computational fluid dynamics (CFD) simulations. The authors then optimized this surrogate model to obtain ideal processing conditions. The optimization problem is given by:","category":"page"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"beginaligned\nmax_mathbf x in X B_2 + sum_r = 1^3 W_2r frac21 + exp (-2y_r + B_1r) rm where y_r = sum_i = 1^8 W_1ir x_i\nendaligned","category":"page"},{"location":"examples/explicit_ann/#Input-Parameters","page":"Standard-Use Example 1","title":"Input Parameters","text":"","category":"section"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"In the first block, we input parameters values supplied in the paper for W_1, W_2, B_1, and B_2 into Julia as simple array objects. We also input bounds for the variables which are used to scale the values obtained from optimization from -1 1 back into the design values.","category":"page"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"using JuMP, EAGO\n\n# Weights associated with the hidden layer\nW1 = [0.54, -1.97, 0.09, -2.14, 1.01, -0.58, 0.45, 0.26;\n -0.81, -0.74, 0.63, -1.60, -0.56, -1.05, 1.23, 0.93;\n -0.11, -0.38, -1.19, 0.43, 1.21, 2.78, -0.06, 0.40]\n\n# Weights associated with the output layer\nW2 = [-0.91, 0.11, 0.52]\n\n# Bias associated with the hidden layer\nB1 = [-2.698, 0.012, 2.926]\n\n# Bias associated with the output layer\nB2 = -0.46\n\n# Variable bounds (Used to scale variables after optimization)\nxLBD = [0.623, 0.093, 0.259, 6.56, 1114.0, 0.013, 0.127, 0.004]\nxUBD = [5.89, 0.5, 1.0, 90.0, 25000.0, 0.149, 0.889, 0.049]","category":"page"},{"location":"examples/explicit_ann/#Construct-the-JuMP-Model-and-Optimize","page":"Standard-Use Example 1","title":"Construct the JuMP Model and Optimize","text":"","category":"section"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"We now formulate the problem using standard JuMP [3] syntax and optimize it. Note that we are using the @NLexpression macro to handle the summation term to keep the code visually simple, but this could be placed directly in the @NLobjective macro instead.","category":"page"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"# Model construction\nmodel = Model(optimizer_with_attributes(EAGO.Optimizer, \"absolute_tolerance\" => 0.001))\n@variable(model, -1.0 <= x[i=1:8] <= 1.0)\n@NLexpression(model, y[r=1:3], sum(W1[r,i]*x[i] for i in 1:8))\n@NLobjective(model, Max, B2 + sum(W2[r]*(2.0/(1 + exp(-2.0*y[r] + B1[r]))) for r=1:3))\n\n# Solve the model\noptimize!(model)","category":"page"},{"location":"examples/explicit_ann/#Retrieve-Results","page":"Standard-Use Example 1","title":"Retrieve Results","text":"","category":"section"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"We then recover the objective value, the solution values, and termination status codes using standard JuMP syntax. The optimal value and solution values are then rescaled using the variable bounds to obtain their physical interpretations.","category":"page"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"# Access calculated values\nfval = JuMP.objective_value(model)\nxsol = JuMP.value.(x)\nstatus_term = JuMP.termination_status(model)\nstatus_prim = JuMP.primal_status(model)\nprintln(\"EAGO terminated with a status of $status_term and a result code of $status_prim.\")\nprintln(\"The optimal value is: $(round(fval, digits=5)).\")\nprintln(\"The solution found is $(round.(xsol, digits=3)).\")\nprintln(\" \")\n\n# Rescale values back to physical space\nrescaled_fval = ((fval + 1.0)/2.0)*0.07\nrescaled_xsol = ((xsol .+ 1.0)./2.0).*(xUBD - xLBD) .+ xLBD\nprintln(\"Rescaled optimal value and solution values:\")\nprintln(\"The rescaled optimal value is: $(round(rescaled_fval, digits=4))\")\nprintln(\"The rescaled solution is $(round.(rescaled_xsol, digits=3)).\")","category":"page"},{"location":"examples/explicit_ann/#References","page":"Standard-Use Example 1","title":"References","text":"","category":"section"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"J. D. Smith, A. A. Neto, S. Cremaschi, and D. W. Crunkleton, CFD-based optimization of a flooded bed algae bioreactor, Industrial & Engineering Chemistry Research, 52 (2012), pp. 7181–7188.\nA. M. Schweidtmann and A. Mitsos. Global Deterministic Optimization with Artificial Neural Networks Embedded https://arxiv.org/pdf/1801.07114.pdf.\nIain Dunning and Joey Huchette and Miles Lubin. JuMP: A Modeling Language for Mathematical Optimization, SIAM Review, 59 (2017), pp. 295-320.","category":"page"},{"location":"news/#News-for-EAGO-Releases","page":"News","title":"News for EAGO Releases","text":"","category":"section"},{"location":"news/#[v0.8.1](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.8.1)-(June-15,-2023)","page":"News","title":"v0.8.1 (June 15, 2023)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Resolved an issue where integer and binary variables would sometimes throw a MathOptInterface.UpperBoundAlreadySet error.\nAdded the function unbounded_check! which warns users if they are missing variable bounds and sets them to +/- 1E10 by default.\nAdded an EAGO parameter unbounded_check which defaults to true and enables unbounded_check!.\nBumped requirement for PrettyTables.jl to v2+ to accommodate the latest version of DataFrames.jl.","category":"page"},{"location":"news/#[v0.8.0](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.8.0)-(June-12,-2023)","page":"News","title":"v0.8.0 (June 12, 2023)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Updated EAGO for compatibility with the nonlinear expression API changes introduced in JuMP v1.2: https://discourse.julialang.org/t/ann-upcoming-refactoring-of-jumps-nonlinear-api/83052.\nEAGO now uses the MOI.Nonlinear submodule instead of JuMP._Derivatives.\nModels, nodes, expressions, constraints, and operators are now compatible with MOI.\nAdded logic and comparison operators to EAGO.OperatorRegistry.","category":"page"},{"location":"news/#[v0.7.3](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.7.3)-(April-11,-2023)","page":"News","title":"v0.7.3 (April 11, 2023)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Bumped DocStringExtensions.jl compatibility.","category":"page"},{"location":"news/#[v0.7.2](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.7.2)-(November-22,-2022)","page":"News","title":"v0.7.2 (November 22, 2022)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Added support for Julia 1.7.\nBumped NaNMath.jl compatibility.\nAdded help? information for various functions and structures.\nUpdated documentation and some formatting.","category":"page"},{"location":"news/#[v0.7.1](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.7.1)-(June-26,-2022)","page":"News","title":"v0.7.1 (June 26, 2022)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Added the function print_problem_summary, an internal script used to display all constraints, objectives in a linear program which is added to functions for debug purposes while writing code.\nAdjusted default EAGOParameters.\nbranch_cvx_factor: 0.5 => 0.25\nbranch_offset: 0.2 => 0.15\ntime_limit and _time_left: 1000.0 => 3600.0\nobbt_depth: 0 => 6\nobbt_repetitions: 1 => 3\ncut_tolerance_rel: 1E-2 => 1E-3\nAdjusted Ipopt.Optimizer attributes.\nmax_iter: 20000 => 10000\nacceptable_iter: 10000 => 1000\nExcluded test_quadratic_nonconvex_constraint_basic from MOI tests.\nRestricted JuMP compatibility to 1.0.0 - 1.1.1.","category":"page"},{"location":"news/#[v0.7.0](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.7.0)-(March-28,-2022)","page":"News","title":"v0.7.0 (March 28, 2022)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Added envelopes of activation functions: xabsx, logcosh\nAdded variations of estimator_extrema, estimator_under, and estimator_over functions to EAGO for bilinear relaxations.\nMoved various functions and related structures to new files.\nAdded RelaxCache structure to hold relaxed problem information.\nUpdated forward and reverse propagation.\nAdded PrettyTables.jl.\nAdded test examples.\nAdded a memory allocation analysis.\nUpdated documentation.","category":"page"},{"location":"news/#[v0.6.1](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.6.1)-(March-4,-2021)","page":"News","title":"v0.6.1 (March 4, 2021)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Minor update to tests.","category":"page"},{"location":"news/#[v0.6.0](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.6.0)-(February-19,-2021)","page":"News","title":"v0.6.0 (February 19, 2021)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"License changed from CC BY-NC-SA 4.0 to MIT.\nFix deprecated Ipopt constructor.\nFix discrepancy between the returned objective value and the objective evaluated at the solution.\nDramatically decrease allocates and first-run performance of SIP routines.\nAdd two algorithms which modify SIPRes detailed in Djelassi, H. and Mitsos A. 2017.\nFix objective interval fallback function.\nNew SIP interface with extendable subroutines.\nFix x^y relaxation bug.\nAdd issues template.\nAdd SIP subroutine documentation.","category":"page"},{"location":"news/#[v0.5.2](https://github.com/PSORLab/EAGO.jl/commit/bc59c5a8a5e26960c159e06e7b26e2e5c2472956)-(November-18,-2020)","page":"News","title":"v0.5.2 (November 18, 2020)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Fix user specified branching variables.","category":"page"},{"location":"news/#[v0.5.1](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.5.1)-(November-18,-2020)","page":"News","title":"v0.5.1 (November 18, 2020)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Support for Julia ~1 (with limited functionality for Julia 1.0 and 1.1).","category":"page"},{"location":"news/#[v0.5.0](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.5.0)-(November-18,-2020)","page":"News","title":"v0.5.0 (November 18, 2020)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Introduces the register_eago_operators!(m::JuMP.Model) which can be used to register all nonstandard nonlinear terms used in EAGO in any JuMP model.\nIntroduces positive, negative, lower_bnd, upper_bnd, and bnd functions which can be used to enforce bounds on intermediate terms in nonlinear expressions (EAGO.Optimizer only).\nAdds envelopes: abs2, sinpi, cospi, fma, cbrt\nAdds envelopes and functions: xlogx\nAdds envelopes of special functions: erf, erfc, erfinv, erfcinv\nAdds envelopes of activation functions: relu, gelu, elu, selu, swish, sigmoid, softsign, softplus, bisigmoid, pentanh, leaky_relu, param_relu\nError messages in sip_explicit have been made more transparent.\nFixes some issues with documentation image rendering and links.\nDrops appveyor CI and Travis CI in favor of GitHub Actions.","category":"page"},{"location":"news/#[v0.4.2](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.4.2)-(August-28,-2020)","page":"News","title":"v0.4.2 (August 28, 2020)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Support for Julia 1.5.","category":"page"},{"location":"news/#[v0.4.1](https://github.com/PSORLab/EAGO.jl/commit/9c1bcf024a19840a0ac49c8c6da13619a5f3845f#comments)-(June-17,-2020)","page":"News","title":"v0.4.1 (June 17, 2020)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Minor bug fixes.","category":"page"},{"location":"news/#[v0.4.0](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.4.0)-(June-12,-2020)","page":"News","title":"v0.4.0 (June 12, 2020)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Support for new MOI/JuMP RawParameter input and a number of new attributes.\nSeparates McCormick and ReverseMcCormick libraries (now McCormick.jl and ReverseMcCormick.jl) from main package. McCormick.jl is reexported.\nRelaxation calculations now return NaN values on a domain violation.\nTolerance based validation of cuts has been added to generate numerically safe cuts.\nSignificantly simplify internal codebase for EAGO.Optimizer (no changes to API): fully decouples input problem specifications from the formulation used internally, stack only stores variables that are branched on, and a number of internal rearrangements to clearly delineate different routines.\nAdd problem classification preprocessing that throws to simpler routines if LP problem types are detected (enables future support for SOCP, MILP, MISOCP, and Convex forms).\nFix multiple bugs and add more transparent error codes.","category":"page"},{"location":"news/#[v0.3.1](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.3.1)-(January-29,-2020)","page":"News","title":"v0.3.1 (January 29, 2020)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Add unit tests.\nSupport for Julia 1.3.\nFix IntervalContractors.jl dependency issue.","category":"page"},{"location":"news/#[v0.3.0](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.3.0)-(November-5,-2019)","page":"News","title":"v0.3.0 (November 5, 2019)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"This update is intended to be the last to create a large number of breaking changes to the EAGO API. Please review the use cases provided in the documentation to update examples.","category":"page"},{"location":"news/","page":"News","title":"News","text":"A number of performance improvements have been made to the underlying McCormick relaxation library.\nThe optimizer used to construct relaxations is now modified in place.\nAll subproblem storage has been moved to the Optimizer object and storage types (e.g. LowerInfo) have been removed.\nA BinaryMinMaxHeap structure is now used to store nodes.\nSpeed and aesthetics for logging and printing utilities have been updated.\nSubroutines are now customized by creating a subtype of ExtensionType and defining subroutines which dispatch on this new structure.\nParametric interval methods and the Implicit optimizer have been move to a separate package (to be tagged shortly).\nJIT compilation time has been reduced substantially.\nSupport for silent tag and time limits.","category":"page"},{"location":"news/#[v0.2.1](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.2.1)-(July-7,-2019)","page":"News","title":"v0.2.1 (July 7, 2019)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Bug fix for explicit SIP solving routine that occurred for uncertainty sets of dimension greater than 1.\nBug fix for MOI.MAX_SENSE (max objective sense).","category":"page"},{"location":"news/#[v0.2.0](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.2.0)-(June-14,-2019)","page":"News","title":"v0.2.0 (June 14, 2019)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"This update creates a number of breaking changes to the EAGO API. Please review the use cases provided in the documentation to update examples.","category":"page"},{"location":"news/","page":"News","title":"News","text":"Updated to support Julia 1.0+, MathOptInterface (MOI), and MOI construction of subproblems.\nAdditional domain reduction routines available.\nSupport for specialized handling of linear and quadratic terms.\nSignificant performance improvements due to pre-allocation of Wengert tapes and MOI support.\nA more intuitive API for McCormick relaxation construction.","category":"page"},{"location":"news/#[v0.1.2](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.1.2)-(June-20,-2018)","page":"News","title":"v0.1.2 (June 20, 2018)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Significant speed and functionality updates.","category":"page"},{"location":"news/#[v0.1.1](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.1.1)-(June-7,-2018)","page":"News","title":"v0.1.1 (June 7, 2018)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Initial release of combined EAGO packages.","category":"page"},{"location":"news/#[v0.1.0](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.1.0)-(April-10,-2018)","page":"News","title":"v0.1.0 (April 10, 2018)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Main global solver release.","category":"page"},{"location":"mccormick/overview/#Overview","page":"Overview","title":"Overview","text":"","category":"section"},{"location":"mccormick/overview/","page":"Overview","title":"Overview","text":"EAGO provides a library of McCormick relaxations in native Julia code. The EAGO optimizer supports relaxing functions using nonsmooth McCormick relaxations (Mitsos2009, Scott2011), smooth McCormick relaxations (Khan2016, Khan2018, Khan2019), and multi-variant McCormick relaxations (Tsoukalas2014; a variant of subgradient-based interval refinement (Najman2017)). For functions with arbitrarily differentiable relaxations, the differentiable constant μ can be modified by adjusting a constant value in the package. Additionally, validated and nonvalidated interval bounds are supported via IntervalArithmetic.jl which is reexported. The basic McCormick operator and reverse McCormick operator (Wechsung2015) libraries are included in two dependent subpackages which can loaded and used independently:","category":"page"},{"location":"mccormick/overview/","page":"Overview","title":"Overview","text":"McCormick.jl: A forward McCormick operator library\nReverseMcCormick.jl: A reverse McCormick operator library","category":"page"},{"location":"mccormick/overview/#NaN-Numerics","page":"Overview","title":"NaN Numerics","text":"","category":"section"},{"location":"mccormick/overview/","page":"Overview","title":"Overview","text":"When a relaxation is computed at an undefined point or over an unbounded domain, the resulting relaxation is defined as \"not a number\" (NaN) rather than throwing an error. This allows algorithms to check for these cases without resorting to try-catch statements. Moreover, when the interval domain is extensive enough to cause a domain violation, an x::MC structure is returned that satisfies isnan(x) === true.","category":"page"},{"location":"mccormick/overview/#References","page":"Overview","title":"References","text":"","category":"section"},{"location":"mccormick/overview/","page":"Overview","title":"Overview","text":"Khan KA, Watson HAJ, Barton PI (2017). Differentiable McCormick relaxations. Journal of Global Optimization, 67(4): 687-729.\nKhan KA, Wilhelm ME, Stuber MD, Cao H, Watson HAJ, Barton PI (2018). Corrections to: Differentiable McCormick relaxations. Journal of Global Optimization, 70(3): 705-706.\nKhan KA (2019). Whitney differentiability of optimal-value functions for bound-constrained convex programming problems. Optimization, 68(2-3): 691-711\nMitsos A, Chachuat B, and Barton PI. (2009). McCormick-based relaxations of algorithms. SIAM Journal on Optimization, 20(2): 573–601.\nNajman J, Bongratz D, Tsoukalas A, and Mitsos A (2017). Erratum to: Multivariate McCormick relaxations. Journal of Global Optimization, 68: 219-225.\nScott JK, Stuber MD, and Barton PI. (2011). Generalized McCormick relaxations. Journal of Global Optimization, 51(4): 569–606.\nStuber MD, Scott JK, Barton PI (2015). Convex and concave relaxations of implicit functions. Optim. Methods Softw., 30(3): 424–460\nTsoukalas A and Mitsos A (2014). Multivariate McCormick Relaxations. Journal of Global Optimization, 59: 633–662.\nWechsung A, Scott JK, Watson HAJ, and Barton PI. (2015). Reverse propagation of McCormick relaxations. Journal of Global Optimization, 63(1): 1-36.","category":"page"},{"location":"optimizer/optimizer/#EAGO-Optimizer","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"","category":"section"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"The Optimizer object holds all algorithm solution information. A description of all user-facing options has been provided in the docstring.","category":"page"},{"location":"optimizer/optimizer/#EAGO.Optimizer","page":"EAGO Optimizer","title":"EAGO.Optimizer","text":"","category":"section"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"Optimizer","category":"page"},{"location":"optimizer/optimizer/#EAGO.Optimizer","page":"EAGO Optimizer","title":"EAGO.Optimizer","text":"mutable struct Optimizer{Q, S, T} <: MathOptInterface.AbstractOptimizer\n\nThe 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:\n\nrelaxed_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}.\nupper_optimizer::MOI.AbstractOptimizer: Optimizer used to solve upper bounding problems (default = Ipopt.Optimizer()). Located in subsolver_block::SubSolvers{Q,S,T}.\next::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}.\nenable_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}.\nobbt_variable_values::Vector{Bool}: Variables to perform OBBT on (default: all variables in nonlinear expressions). Located in _global_optimizer::GlobalOptimizer{Q,S,T}.\n\nDescriptions of all Optimizer fields available in extended help.\n\nExtended Help\n\nsubsolver_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\nenable_optimize_hook::Bool: Specifies that the optimize_hook! function should be called rather than throw the problem to the standard routine\next::Union{Nothing, T} where T: (Deprecated, use subsolver_block instead) Storage for custom extension types\n_auxiliary_variable_info::Union{Nothing, EAGO._AuxVarData}: Information on any auxiliary variables\n_global_optimizer::GlobalOptimizer{Q, S, T} where {Q, S, T}: Additional options and temporary storage for solving optimization problems\n_input_problem::InputProblem: Expressions and constraints added to the EAGO model (not directly used for relaxations)\n_working_problem::ParsedProblem: Expressions and problem descriptions that EAGO uses to formulate relaxed problems\n_parameters::EAGOParameters: Parameters that do not change during a global solve\n_optimizer_attributes_set::Vector{MathOptInterface.AbstractOptimizerAttribute}: Set of optimizer attributes\n_termination_status_code::MathOptInterface.TerminationStatusCode: The MathOptInterface-compliant completion status code\n_result_status_code::MathOptInterface.ResultStatusCode: Value indicating the feasibility status of the result\n_run_time::Float64: Optimization run time\n_objective_value::Float64: The objective value of the primal solution\n_objective_bound::Float64: The best-known bound on the optimal objective value\n_relative_gap::Float64: The gap between the upper and lower bound, relative to the bound with the larger magnitude\n_iteration_count::Int64: The number of iterations the branch-and-bound algorithm has completed\n_node_count::Int64: The number of nodes in the stack\n\n\n\n\n\n","category":"type"},{"location":"optimizer/optimizer/#EAGO-Specific-Functions-and-Operators","page":"EAGO Optimizer","title":"EAGO Specific Functions and Operators","text":"","category":"section"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"EAGO supports a number of functions and operators that for which specialized relaxation routines are available. These can be registered and added to a JuMP model using the function:","category":"page"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"EAGO.register_eago_operators!(m::JuMP.Model)","category":"page"},{"location":"optimizer/optimizer/#EAGO.register_eago_operators!-Tuple{Model}","page":"EAGO Optimizer","title":"EAGO.register_eago_operators!","text":"registereagooperators!\n\nRegisters all nonstandard nonlinear terms available in EAGO in a JuMP. Uses of these is generally preferable in EAGO as the relaxations EAGO will generate will usually be tighter (speeding up convergence time). Note that this will work can be used by other nonlinear solvers (Ipopt for instance).\n\n\n\n\n\n","category":"method"},{"location":"optimizer/optimizer/#Storage-for-Input-Parameters","page":"EAGO Optimizer","title":"Storage for Input Parameters","text":"","category":"section"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"EAGO.EAGOParameters","category":"page"},{"location":"optimizer/optimizer/#EAGO.EAGOParameters","page":"EAGO Optimizer","title":"EAGO.EAGOParameters","text":"mutable struct EAGOParameters\n\nStorage for parameters that do not change during a global solve.\n\npresolve_scrubber_flag::Bool: Should EAGO attempt to remove type-assert issues for user-defined functions (default = false)\npresolve_to_JuMP_flag::Bool: Create and use DAG representations of user-defined functions (default = false)\npresolve_flatten_flag::Bool: Rerrange the DAG using registered transformations (default = false)\nconic_convert_quadratic::Bool: Attempt to bridge convex constraint to second-order cone (default = false)\nlog_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)\nlog_subproblem_info::Bool: Turn on logging of times and feasibility of subproblems (default = false)\nlog_interval::Int64: Log data every log_interval iterations (default = 1)\nverbosity::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)\noutput_iterations::Int64: Display summary of iteration to console every output_iterations (default = 1000)\nheader_iterations::Int64: Display header for summary to console every output_iterations (default = 100000)\nbranch_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)\nbranch_offset::Float64: Minimum distance from bound to have branch point, normalized by width of dimension to branch on (default = 0.15)\nbranch_pseudocost_on::Bool: Indicate that pseudocost branching should be used (default = false)\nbranch_variable::Vector{Bool}: Variables to branch on (default is all nonlinear)\nbranch_max_repetitions::Int64: [FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED] Number of times to repeat node processing prior to branching (default = 4)\nbranch_repetition_tol::Float64: [FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED] Volume ratio tolerance required to repeat processing the current node (default = 0.9)\nnode_limit::Int64: Maximum number of nodes (default = 1E7)\ntime_limit::Float64: Maximum CPU time in seconds (default = 3600)\niteration_limit::Int64: Maximum number of iterations (default 1E9)\nabsolute_tolerance::Float64: Absolute tolerance for termination (default = 1E-3)\nrelative_tolerance::Float64: Relative tolerance for termination (default = 1E-3)\nabsolute_constraint_feas_tolerance::Float64: Absolute constraint feasibility tolerance (default = 1E-8)\ncp_depth::Int64: Depth in B&B tree above which constraint propagation should be disabled (default = 0)\ncp_repetitions::Int64: Number of times to repeat forward-reverse pass routine (default = 0)\ncp_tolerance::Float64: Disable constraint propagation if the ratio of new node volume to beginning node volume exceeds this number (default = 0.99)\ncp_interval_only::Bool: Use only valid interval bounds during constraint propagation (default = false)\nobbt_depth::Int64: Depth in B&B tree above which OBBT should be disabled (default = 6)\nobbt_repetitions::Int64: Number of repetitions of OBBT to perform in preprocessing (default = 3)\nobbt_aggressive_on::Bool: Turn on aggresive OBBT (default = true)\nobbt_aggressive_max_iteration::Int64: Maximum iteration to perform aggresive OBBT (default = 2)\nobbt_aggressive_min_dimension::Int64: Minimum dimension to perform aggresive OBBT (default = 2)\nobbt_tolerance::Float64: Tolerance to consider bounds equal (default = 1E-10)\nfbbt_lp_depth::Int64: Depth in B&B tree above which linear FBBT should be disabled (default = 1000)\nfbbt_lp_repetitions::Int64: Number of repetitions of linear FBBT to perform in preprocessing (default = 3)\ndbbt_depth::Int64: Depth in B&B tree above which duality-based bound tightening should be disabled (default = 1E10)\ndbbt_tolerance::Float64: New bound is considered equal to the prior bound if within dbbt_tolerance (default = 1E-8)\nrelax_tag::RelaxTag: RelaxTag used to specify type of McCormick operator (default = NS())\nsubgrad_tighten::Bool: Perform tightening of interval bounds using subgradients at each factor in each nonlinear tape during a forward pass (default = true)\nreverse_subgrad_tighten::Bool: Perform tightening of interval bounds using subgradients at each factor in each nonlinear tape during a reverse pass (default = false)\nsubgrad_tol::Float64: Outer-round computed subgradient bounds by this amount (default = 1E-10)\nmul_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)\ncut_min_iterations::Int64: Minimum number of cuts at each node to attempt (unsafe cuts not necessarily added) (default = 2)\ncut_max_iterations::Int64: Maximum number of cuts at each node to attempt (default = 8)\ncut_tolerance_abs::Float64: Absolute tolerance checked for continuing cut (default = 1E-6)\ncut_tolerance_rel::Float64: Relative tolerance checked for continuing cut (default = 1E-3)\ncut_safe_on::Bool: Use tolerances to determine safe cuts in a Khajavirad 2018 manner (default = true)\ncut_safe_l::Float64: Lower tolerance for safe-lp cut, Khajavirad 2018 (default = 1E-7)\ncut_safe_u::Float64: Upper tolerance for safe-lp cut, Khajavirad 2018 (default = 1E7)\ncut_safe_b::Float64: Constant tolerance for safe-lp cut, Khajavirad 2018 (default = 1E9)\nupper_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)\ndomain_violation_guard_on::Bool: (Unused) Protect against domain violation (default = false)\ndomain_violation_ϵ::Float64: (Unused) Amount about a domain violation to ignore when propagating bounds (default = 1E-9)\nuser_solver_config::Bool: If true, EAGO forgoes its default configuration process for subsolvers (default = false)\ninteger_abs_tol::Float64: Absolute tolerance used to check for integrality of decision variables (default = 1E-9)\ninteger_rel_tol::Float64: Relative tolerance used to check for integrality of decision variables (default = 1E-9)\nforce_global_solve::Bool: Ignore EAGO's ability to parse problem types and force it to run global optimization (default = false)\nunbounded_check::Bool: Check that all branching variables have finite bounds and set them to +/- 1E10 if not (default = true)\n\n\n\n\n\n","category":"type"},{"location":"optimizer/optimizer/#Internal-Storage-Structures","page":"EAGO Optimizer","title":"Internal Storage Structures","text":"","category":"section"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"VariableInfo\nExtensionType","category":"page"},{"location":"optimizer/optimizer/#EAGO.VariableInfo","page":"EAGO Optimizer","title":"EAGO.VariableInfo","text":"struct VariableInfo{T<:AbstractFloat}\n\nA structure used to store information related to the bounds assigned to each variable.\n\nis_integer::Bool: Is the variable integer valued?\nhas_lower_bound::Bool: Boolean indicating whether a finite lower bound exists.\nhas_upper_bound::Bool: Boolean indicating whether a finite upper bound exists.\nis_fixed::Bool: Boolean indicating if variable is fixed to a finite value.\nhas_constraints::Bool: Boolean indicating that constraints have been set\nlower_bound::AbstractFloat: Lower bound. May be -Inf.\nupper_bound::AbstractFloat: Upper bound. May be Inf.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/optimizer/#EAGO.ExtensionType","page":"EAGO Optimizer","title":"EAGO.ExtensionType","text":"abstract type ExtensionType\n\nAn 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.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/optimizer/#Internal-Problem-Representations","page":"EAGO Optimizer","title":"Internal Problem Representations","text":"","category":"section"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"EAGO.InputProblem\nEAGO.ParsedProblem","category":"page"},{"location":"optimizer/optimizer/#EAGO.InputProblem","page":"EAGO Optimizer","title":"EAGO.InputProblem","text":"mutable struct InputProblem\n\nA structure used to hold objectives and constraints added to the EAGO model. The constraints generally aren't used for relaxations.\n\nAll field information available in extended help.\n\nExtended Help\n\n_variable_count::Int64: Count for the number of variables\n_variable_names::Dict{MathOptInterface.VariableIndex, String}: Dictionary containing variable indices and their names\n_constraint_count::Int64: Count for the number of constraints\n_vi_leq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}}\n_vi_geq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}}\n_vi_eq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.EqualTo{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.EqualTo{Float64}}}\n_vi_it_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.Interval{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.Interval{Float64}}}\n_vi_zo_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.ZeroOne}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.ZeroOne}}\n_vi_int_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.Integer}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.Integer}}\n_linear_leq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, Tuple{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}}\n_linear_geq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Tuple{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}\n_linear_eq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Tuple{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}}\n_quadratic_leq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}, Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}}\n_quadratic_geq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}\n_quadratic_eq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}}\n_conic_second_order::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VectorOfVariables, MathOptInterface.SecondOrderCone}, Tuple{MathOptInterface.VectorOfVariables, MathOptInterface.SecondOrderCone}}\n_linear_leq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, Float64}\n_linear_geq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Float64}\n_linear_eq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Float64}\n_quadratic_leq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}, Float64}\n_quadratic_geq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Float64}\n_quadratic_eq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Float64}\n_linear_leq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}}\n_linear_geq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}\n_linear_eq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}}\n_quadratic_leq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}}\n_quadratic_geq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}\n_quadratic_eq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}}\n_objective::Union{Nothing, MathOptInterface.VariableIndex, MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.ScalarQuadraticFunction{Float64}}: Storage for the objective function\n_nlp_data::Union{Nothing, MathOptInterface.NLPBlockData}: Storage for NLP constraints (set by MOI.set(m, ::NLPBlockData...) in moi_wrapper.jl)\n_optimization_sense::MathOptInterface.OptimizationSense: Objective sense information (set by MOI.set(m, ::ObjectiveSense...))\n\n\n\n\n\n","category":"type"},{"location":"optimizer/optimizer/#EAGO.ParsedProblem","page":"EAGO Optimizer","title":"EAGO.ParsedProblem","text":"mutable struct ParsedProblem\n\nA structure used to store expressions and problem descriptions EAGO uses to formulate relaxed problems.\n\nAll field information available in extended help.\n\nExtended Help\n\n_problem_type::Union{Nothing, EAGO.DIFF_CVX, EAGO.LP, EAGO.MILP, EAGO.MINCVX, EAGO.MISOCP, EAGO.SOCP}: Problem classification (set in parse_classify_problem!)\n_objective_saf::MathOptInterface.ScalarAffineFunction{Float64}: Stores the objective and is used for constructing linear affine cuts\n_objective::Union{Nothing, MathOptInterface.VariableIndex, EAGO.AffineFunctionIneq, EAGO.BufferedQuadraticIneq, EAGO.BufferedNonlinearFunction}: Storage for the objective function\n_optimization_sense::MathOptInterface.OptimizationSense: Objective sense information (set by MOI.set(m, ::ObjectiveSense...))\n_saf_leq::Vector{EAGO.AffineFunctionIneq}\n_saf_eq::Vector{EAGO.AffineFunctionEq}\n_sqf_leq::Vector{EAGO.BufferedQuadraticIneq}\n_sqf_eq::Vector{EAGO.BufferedQuadraticEq}\n_conic_second_order::Vector{EAGO.BufferedSOC}\n_nlp_data::Union{Nothing, MathOptInterface.NLPBlockData}\n_nonlinear_constr::Vector{EAGO.BufferedNonlinearFunction}\n_relaxed_evaluator::Evaluator\n_variable_info::Vector{VariableInfo{Float64}}: Variable information (set in initial_parse!)\n_variable_count::Int64: Count for the number of variables\n\n\n\n\n\n","category":"type"},{"location":"optimizer/optimizer/#Interval-Optimizer-Subroutines","page":"EAGO Optimizer","title":"Interval Optimizer Subroutines","text":"","category":"section"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"EAGO.initial_parse!(m::Optimizer{R,S,T}) where {R,S,T}","category":"page"},{"location":"optimizer/optimizer/#EAGO.initial_parse!-Union{Tuple{Optimizer{R, S, T}}, Tuple{T}, Tuple{S}, Tuple{R}} where {R, S, T}","page":"EAGO Optimizer","title":"EAGO.initial_parse!","text":"initial_parse!(m::Optimizer{R, S, T})\n\n\nTranslate the input problem to the working problem. Any checks or optional manipulation are left to the presolve stage.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/optimizer/#Extending-EAGO","page":"EAGO Optimizer","title":"Extending EAGO","text":"","category":"section"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"Functionality has been included that allows for extensions to EAGO's Optimizer to be readily defined. This can be done in two ways first defining a new structure which is a subtype of ExtensionType and overloading methods associated with this new structure. An instance of this new structure is provided to the Optimizer using the ext_type keyword. This results in EAGO now dispatch to the new methods rather than the generally defined methods for the parent type. For a complete example, the reader is directed to the interval bounding example and the quasiconvex example. Alternatively, the user can overload the optimize_hook! for this subtype which will entirely circumvent the default global solution routine. Additional information can be stored in the ext field of the Optimizer. In order to allow for compatibility between packages the user is encouraged to append their extension name to the start of each variable name (e.g. newext_newdata).","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"","category":"page"},{"location":"jump/README/#EAGO-Easy-Advanced-Global-Optimization","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"","category":"section"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"EAGO is an open-source development environment for robust and global optimization in Julia. See the full README for more information.","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"PSOR Lab Current Version Build Status Documentation\n(Image: ) (Image: ) (Image: Build Status) (Image: codecov) (Image: )","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"EAGO is a deterministic global optimizer designed to address a wide variety of optimization problems, emphasizing nonlinear programs (NLPs), by propagating McCormick relaxations along the factorable structure of each expression in the NLP. Most operators supported by modern automatic differentiation (AD) packages are supported by EAGO and a number utilities for sanitizing native Julia code and generating relaxations on a wide variety of user-defined functions have been included. Currently, EAGO supports problems that have a priori variable bounds defined and have differentiable constraints. That is, problems should be specified in the generic form below:","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"$","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"\\begin{align} f^{\\} = & \\min{\\mathbf y \\in Y \\subset \\mathbb R^{n{y}}} f(\\mathbf y) \\\n{\\rm s.t.} \\;\\; & \\mathbf h(\\mathbf y) = \\mathbf 0 \\\n& \\mathbf g(\\mathbf y) \\leq \\mathbf 0 \\\n& Y = [\\mathbf y^{\\mathbf L}, \\mathbf y^{\\mathbf U}] \\in \\mathbb{IR}^{n} \\\n& \\qquad \\mathbf y^{\\mathbf L}, \\mathbf y^{\\mathbf U} \\in \\mathbb R^{n} \\end{align*} $","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"For each nonlinear term, EAGO makes use of factorable representations to construct bounds and relaxations. In the case of f(x) = x (x - 5) sin(x), a list is generated and rules for constructing McCormick relaxations are used to formulate relaxations in the original decision space, X [1]:","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"v_1 = x\nv_2 = v_1 - 5\nv_3 = sin(v_1)\nv_4 = v_1 v_2\nv_5 = v_4 v_3\nf(x) = v_5","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"

","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"Either these original relaxations, differentiable McCormick relaxations [2], or affine relaxations thereof can be used to construct relaxations of optimization problems useful in branch and bound routines for global optimization. Utilities are included to combine these with algorithms for relaxing implicit functions [3] and forward-reverse propagation of McCormick arithmetic [4].","category":"page"},{"location":"jump/README/#License","page":"EAGO - Easy Advanced Global Optimization","title":"License","text":"","category":"section"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"EAGO is licensed under the MIT License.","category":"page"},{"location":"jump/README/#Installation","page":"EAGO - Easy Advanced Global Optimization","title":"Installation","text":"","category":"section"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"EAGO is a registered Julia package and it can be installed using the Julia package manager:","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"import Pkg\nPkg.add(\"EAGO\")","category":"page"},{"location":"jump/README/#Use-with-JuMP","page":"EAGO - Easy Advanced Global Optimization","title":"Use with JuMP","text":"","category":"section"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"EAGO makes use of JuMP to improve the user's experience in setting up optimization models. Consider the \"process\" problem instance from [5]:","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"$","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"\\begin{align} & \\max{\\mathbf x \\in X} 0.063 x{4} x{7} - 5.04 x{1} - 0.035 x{2} - 10 x{3} - 3.36 x{2} \\\n{\\rm s.t.} \\;\\; & x{1} (1.12 + 0.13167 x{8} - 0.00667 x{8}^{2}) + x{4} = 0 \\\n& -0.001 x{4} x{9} x{6} / (98 - x{6}) + x{3} = 0 \\\n& -(1.098 x{8} - 0.038 x{8}^{2}) - 0.325 x{6} + x{7} = 0 \\\n& -(x{2} + x{5}) / x{1} + x{8} = 0 \\\n& -x{1} + 1.22 x{4} - x{5} = 0 \\\n& x{9} + 0.222 x{10} - 35.82 = 0 \\\n& -3.0 x{7} + x_{10} + 133.0 = 0 \\\n& X = [10, 2000] \\times [0, 16000] \\times [0, 120] \\times [0, 5000] \\\n& \\qquad \\times [0, 2000] \\times [85, 93] \\times [90,9 5] \\times [3, 12] \\times [1.2, 4] \\times [145, 162] \\end{align} $","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"This model can be formulated in Julia as:","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"using JuMP, EAGO\n\n# Build model using EAGO's optimizer\nm = Model(EAGO.Optimizer)\n\n# Define bounded variables\nxL = [10.0; 0.0; 0.0; 0.0; 0.0; 85.0; 90.0; 3.0; 1.2; 145.0]\nxU = [2000.0; 16000.0; 120.0; 5000.0; 2000.0; 93.0; 95.0; 12.0; 4.0; 162.0]\n@variable(m, xL[i] <= x[i=1:10] <= xU[i])\n\n# Define nonlinear constraints\n@NLconstraint(m, e1, -x[1]*(1.12 + 0.13167*x[8] - 0.00667*(x[8])^2) + x[4] == 0.0)\n@NLconstraint(m, e3, -0.001*x[4]*x[9]*x[6]/(98.0 - x[6]) + x[3] == 0.0)\n@NLconstraint(m, e4, -(1.098*x[8] - 0.038*(x[8])^2) - 0.325*x[6] + x[7] == 57.425)\n@NLconstraint(m, e5, -(x[2] + x[5])/x[1] + x[8] == 0.0)\n\n# Define linear constraints\n@constraint(m, e2, -x[1] + 1.22*x[4] - x[5] == 0.0)\n@constraint(m, e6, x[9] + 0.222*x[10] == 35.82)\n@constraint(m, e7, -3.0*x[7] + x[10] == -133.0)\n\n# Define nonlinear objective\n@NLobjective(m, Max, 0.063*x[4]*x[7] - 5.04*x[1] - 0.035*x[2] - 10*x[3] - 3.36*x[5])\n\n# Solve the optimization problem\nJuMP.optimize!(m)","category":"page"},{"location":"jump/README/#Documentation","page":"EAGO - Easy Advanced Global Optimization","title":"Documentation","text":"","category":"section"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"EAGO has numerous features: a solver accessible from JuMP/MathOptInterface (MOI), domain reduction routines, McCormick relaxations, and specialized nonconvex semi-infinite program solvers. A full description of all features can be found on the documentation website. A series of example have been provided in the documentation and in the form of Jupyter Notebooks in the separate EAGO-notebooks repository.","category":"page"},{"location":"jump/README/#A-Cautionary-Note-on-Global-Optimization","page":"EAGO - Easy Advanced Global Optimization","title":"A Cautionary Note on Global Optimization","text":"","category":"section"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"As a global optimization platform, EAGO's solvers can be used to find solutions of general nonconvex problems with a guaranteed certificate of optimality. However, global solvers suffer from the curse of dimensionality and therefore their performance is outstripped by convex/local solvers. For users interested in large-scale applications, be warned that problems generally larger than a few variables may prove challenging for certain types of global optimization problems.","category":"page"},{"location":"jump/README/#Citing-EAGO","page":"EAGO - Easy Advanced Global Optimization","title":"Citing EAGO","text":"","category":"section"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"Please cite the following paper when using EAGO. In plain text form this is:","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"Wilhelm, M.E. and Stuber, M.D. EAGO.jl: easy advanced global optimization in Julia.\nOptimization Methods and Software. 37(2): 425-450 (2022). DOI: 10.1080/10556788.2020.1786566","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"As a BibTeX entry:","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"@article{doi:10.1080/10556788.2020.1786566,\nauthor = {Wilhelm, M.E. and Stuber, M.D.},\ntitle = {EAGO.jl: easy advanced global optimization in Julia},\njournal = {Optimization Methods and Software},\nvolume = {37},\nnumber = {2},\npages = {425-450},\nyear = {2022},\npublisher = {Taylor & Francis},\ndoi = {10.1080/10556788.2020.1786566},\nURL = {https://doi.org/10.1080/10556788.2020.1786566},\neprint = {https://doi.org/10.1080/10556788.2020.1786566}\n}","category":"page"},{"location":"jump/README/#References","page":"EAGO - Easy Advanced Global Optimization","title":"References","text":"","category":"section"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"Mitsos, A., Chachuat, B., and Barton, P.I. McCormick-based relaxations of algorithms. SIAM Journal on Optimization. 20(2): 573–601 (2009).\nKhan, K.A., Watson, H.A.J., and Barton, P.I. Differentiable McCormick relaxations. Journal of Global Optimization. 67(4): 687-729 (2017).\nStuber, M.D., Scott, J.K., and Barton, P.I.: Convex and concave relaxations of implicit functions. Optimization Methods and Software 30(3): 424–460 (2015).\nWechsung, A., Scott, J.K., Watson, H.A.J., and Barton, P.I. Reverse propagation of McCormick relaxations. Journal of Global Optimization 63(1): 1-36 (2015).\nBracken, J., and McCormick, G.P. Selected Applications of Nonlinear Programming. John Wiley and Sons, New York (1968).","category":"page"},{"location":"optimizer/udf_utilities/#User-Defined-Functions-and-Directed-Acyclic-Graph-Utilities","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"User-Defined Functions and Directed Acyclic Graph Utilities","text":"","category":"section"},{"location":"optimizer/udf_utilities/","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"User-Defined Functions and Directed Acyclic Graph Utilities","text":"EAGO has included basic functionality to manipulate user-defined functions (UDFs). EAGO also has utilities for directed acyclic graphs (DAGs). These features are largely experimental and we're interested in providing additional features for novel use cases.","category":"page"},{"location":"optimizer/udf_utilities/#DAG-Substitution-and-Flattening","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"DAG Substitution and Flattening","text":"","category":"section"},{"location":"optimizer/udf_utilities/","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"User-Defined Functions and Directed Acyclic Graph Utilities","text":"dag_flattening!\nflatten_expression!\nregister_substitution!\nTemplate_Graph\nTemplate_Node","category":"page"},{"location":"optimizer/udf_utilities/#EAGO.Script.dag_flattening!","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"EAGO.Script.dag_flattening!","text":"dag_flattening!\n\nFlattens (usually) the dag by making all registered substitutions for every nonlinear term in the Optimizer.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/udf_utilities/#EAGO.Script.flatten_expression!","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"EAGO.Script.flatten_expression!","text":"flatten_expression!\n\nFlattens (usually) the dag by making all registered substitutions for the expression expr::MOINL.Expression. Performs a depth-first search through the expression adding the terminal node to the stack, then checking to determine if it matches a registered substitution pattern. If it doesn't not then node is added to the new expression graph representation and it's children are added to the queue. If an expression (node) is identified as a pattern then it is substituted and any children expression nodes are then checked for patterns until the depth first search is exhausted.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/udf_utilities/#EAGO.Script.register_substitution!","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"EAGO.Script.register_substitution!","text":"register_substitution!\n\nSpecifies that the src::Template_Graph should be subsituted out for the trg::Template_Graph.\n\nConventions for substition, the expression to be checked always appears at key 1 in the Template_Graph and operations are ordered from low value to high value left to right so if 1 is a -, and 4 => 1, 3 => 1 then the expression is 4 - 3\n\n\n\n\n\n","category":"function"},{"location":"optimizer/udf_utilities/#EAGO.Script.Template_Graph","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"EAGO.Script.Template_Graph","text":"Template_Graph\n\nHolds a list of Template_Nodes, set of directed edges, lengths, an adjacency matrix and the number of children.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/udf_utilities/#EAGO.Script.Template_Node","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"EAGO.Script.Template_Node","text":"Template_Node\n\nA structure which holds a symbol indicating whether the node is an operator, a number, or an expression type, a value which identifies the function or symbol value, potentially a numeric value num_value, and a check that can be run to verify the node is correct check.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/udf_utilities/#UDF-Scrubber","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"UDF Scrubber","text":"","category":"section"},{"location":"optimizer/udf_utilities/","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"User-Defined Functions and Directed Acyclic Graph Utilities","text":"scrub\nscrub!","category":"page"},{"location":"dev/contributing/#How-to-Contribute-to-EAGO","page":"Contributing","title":"How to Contribute to EAGO","text":"","category":"section"},{"location":"dev/contributing/","page":"Contributing","title":"Contributing","text":"We're always happy to welcome work with additional collaborators and contributors. One of the easy ways for newcomers to contribute is by adding additional McCormick relaxations.","category":"page"},{"location":"dev/contributing/","page":"Contributing","title":"Contributing","text":"If you have any requests for additional functionality, bug fixes, or comments, please feel free to open a new issue using the GitHub issue tracker or reach out to us.","category":"page"},{"location":"dev/contributing/#Contact-Us","page":"Contributing","title":"Contact Us","text":"","category":"section"},{"location":"dev/contributing/","page":"Contributing","title":"Contributing","text":"Please direct technical issues and/or bugs to the active developers: ","category":"page"},{"location":"dev/contributing/","page":"Contributing","title":"Contributing","text":"Robert Gottlieb\nDimitri Alston","category":"page"},{"location":"dev/contributing/","page":"Contributing","title":"Contributing","text":"All other questions should be directed to Prof. Stuber.","category":"page"},{"location":"mccormick/implicit/#Relaxation-of-Implicit-Functions","page":"Relaxation of Implicit Functions","title":"Relaxation of Implicit Functions","text":"","category":"section"},{"location":"mccormick/implicit/#High-Level-Functions","page":"Relaxation of Implicit Functions","title":"High-Level Functions","text":"","category":"section"},{"location":"mccormick/implicit/","page":"Relaxation of Implicit Functions","title":"Relaxation of Implicit Functions","text":"implicit_relax_h!","category":"page"},{"location":"mccormick/implicit/#McCormick.implicit_relax_h!","page":"Relaxation of Implicit Functions","title":"McCormick.implicit_relax_h!","text":"implicit_relax_h!(d)\nimplicit_relax_h!(d, interval_bnds)\n\n\nCompute relaxations of x(p) defined by h(x,p) = 0 where h is specifed as h(out, x, p).\n\n\n\n\n\n","category":"function"},{"location":"mccormick/implicit/#Data-Structures","page":"Relaxation of Implicit Functions","title":"Data Structures","text":"","category":"section"},{"location":"mccormick/implicit/","page":"Relaxation of Implicit Functions","title":"Relaxation of Implicit Functions","text":"McCormick.AbstractContractorMC\nNewtonGS\nKrawczykCW\nMcCormick.AbstractPreconditionerMC\nDenseMidInv\nMcCormick.AbstractMCCallback\nMCCallback","category":"page"},{"location":"mccormick/implicit/#McCormick.AbstractContractorMC","page":"Relaxation of Implicit Functions","title":"McCormick.AbstractContractorMC","text":"abstract type AbstractContractorMC\n\nAn abstract type for each manner of contractor using in the implicit function relaxation algorithms.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/implicit/#McCormick.NewtonGS","page":"Relaxation of Implicit Functions","title":"McCormick.NewtonGS","text":"struct NewtonGS <: McCormick.AbstractContractorMC\n\nThe Gauss-Seidel implementation of the Newton contractor used in the implicit relaxation scheme.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/implicit/#McCormick.KrawczykCW","page":"Relaxation of Implicit Functions","title":"McCormick.KrawczykCW","text":"struct KrawczykCW <: McCormick.AbstractContractorMC\n\nThe componentwise implementation of the Krawczyk contractor used in the implicit relaxation scheme.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/implicit/#McCormick.AbstractPreconditionerMC","page":"Relaxation of Implicit Functions","title":"McCormick.AbstractPreconditionerMC","text":"abstract type AbstractPreconditionerMC\n\nAn abstract type for each manner of preconditioner used in the implicit function relaxation algorithms.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/implicit/#McCormick.DenseMidInv","page":"Relaxation of Implicit Functions","title":"McCormick.DenseMidInv","text":"struct DenseMidInv{S<:VecOrMat{Float64}} <: McCormick.AbstractPreconditionerMC\n\nA dense LU preconditioner for implicit McCormick relaxation.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/implicit/#McCormick.AbstractMCCallback","page":"Relaxation of Implicit Functions","title":"McCormick.AbstractMCCallback","text":"abstract type AbstractMCCallback\n\nAn abstract type for each manner of callback functions used in the implicit function relaxation algorithms.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/implicit/#McCormick.MCCallback","page":"Relaxation of Implicit Functions","title":"McCormick.MCCallback","text":"mutable struct MCCallback{FH, FJ, C<:McCormick.AbstractContractorMC, PRE<:McCormick.AbstractPreconditionerMC, N, T<:RelaxTag, AMAT<:(AbstractMatrix)} <: AbstractMCCallback\n\nA structure used to compute implicit relaxations.\n\nh!::Any: Function h(x,p) = 0 defined in place by h!(out,x,p)\nhj!::Any: Jacobian of h(x,p) w.r.t x\nH::Array{MC{N, T}, 1} where {N, T<:RelaxTag}: Intermediate inplace storage for output of h!\nJ::AbstractMatrix: Intermediate inplace storage for output of hj!\nJ0::Vector{AMAT} where AMAT<:(AbstractMatrix)\nxz0::Vector{AMAT} where AMAT<:(AbstractMatrix)\nxmid::Vector{Float64}\nX::Vector{Interval{Float64}}: State space x interval bounds\nP::Vector{Interval{Float64}}: Decision space p interval bounds\nnx::Int64: State space dimension\nnp::Int64: Decision space dimension\nλ::Float64: Convex combination parameter\neps::Float64: Tolerance for interval equality\nkmax::Int64: Number of contractor steps to take\npref_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}: Reference decision point at which affine relaxations are calculated (and used in subsequent calculations).\np_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}: Decision point at which relaxation is evaluated.\np_temp_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}: Vector used to temporarily store p in genexpansionparams! routine.\nx0_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}\nx_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}\nxa_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}\nxA_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}\naff_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}\nz_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}\ncontractor::McCormick.AbstractContractorMC: Type of contractor used in implicit relaxation routine.\npreconditioner::McCormick.AbstractPreconditionerMC: Preconditioner used in the implicit relaxation routine.\napply_precond::Bool: Boolean indicating that the preconditioner should be applied\nparam::Array{Array{MC{N, T}, 1}, 1} where {N, T<:RelaxTag}: Vector of relaxations of x at each iteration used to generated affine relaxations used in intermediate calculation.\nuse_apriori::Bool: Indicates that subgradient-based apriori relaxations of multiplication should be used.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/implicit/#Subroutines","page":"Relaxation of Implicit Functions","title":"Subroutines","text":"","category":"section"},{"location":"mccormick/implicit/","page":"Relaxation of Implicit Functions","title":"Relaxation of Implicit Functions","text":"preconditioner_storage\naffine_exp!\ncorrect_exp!\ncontract!\nprecond_and_contract!\nfinal_cut\ngen_expansion_params!\npopulate_affine!","category":"page"},{"location":"mccormick/implicit/#McCormick.preconditioner_storage","page":"Relaxation of Implicit Functions","title":"McCormick.preconditioner_storage","text":"preconditioner_storage(x, t)\n\n\nCreates storage corresponding to x::AbstractPreconditionerMC and t::T where T<:RelaxTag.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/implicit/#McCormick.affine_exp!","page":"Relaxation of Implicit Functions","title":"McCormick.affine_exp!","text":"affine_exp!(x, p, d)\n\n\nComputates the affine relaxations of the state variable.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/implicit/#McCormick.correct_exp!","page":"Relaxation of Implicit Functions","title":"McCormick.correct_exp!","text":"correct_exp!(d)\n\n\nCorrects the relaxation of the state variable x_mc if the affine relaxation,\n\n\n\n\n\n","category":"function"},{"location":"mccormick/implicit/#McCormick.contract!","page":"Relaxation of Implicit Functions","title":"McCormick.contract!","text":"Performs a single step of the parametric method associated with t assumes that the inputs have been preconditioned.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/implicit/#McCormick.precond_and_contract!","page":"Relaxation of Implicit Functions","title":"McCormick.precond_and_contract!","text":"precond_and_contract!(d!, k, b)\n\n\n\n\n\n\n","category":"function"},{"location":"mccormick/implicit/#McCormick.final_cut","page":"Relaxation of Implicit Functions","title":"McCormick.final_cut","text":"final_cut(x, y)\n\n\nAn operator that cuts the x object using the y bounds in a differentiable or nonsmooth fashion to achieve a composite relaxation within y.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/implicit/#McCormick.gen_expansion_params!","page":"Relaxation of Implicit Functions","title":"McCormick.gen_expansion_params!","text":"gen_expansion_params!(d)\ngen_expansion_params!(d, interval_bnds)\n\n\nConstructs parameters need to compute relaxations of h.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/implicit/#McCormick.populate_affine!","page":"Relaxation of Implicit Functions","title":"McCormick.populate_affine!","text":"populate_affine!(d, interval_bnds)\n\n\nPopulates x_mc, xa_mc, xA_mc, and z_mc with affine bounds.\n\n\n\n\n\n","category":"function"},{"location":"dev/api_types/#Types","page":"Types","title":"Types","text":"","category":"section"},{"location":"dev/api_types/","page":"Types","title":"Types","text":"Modules = [EAGO]\nOrder = [:type]","category":"page"},{"location":"dev/api_types/#EAGO.AbstractCache-dev-api_types","page":"Types","title":"EAGO.AbstractCache","text":"abstract type AbstractCache\n\nAbstract supertype used for information storage object the directed acyclic graph.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.AbstractCacheAttribute-dev-api_types","page":"Types","title":"EAGO.AbstractCacheAttribute","text":"abstract type AbstractCacheAttribute\n\nAbstract supertype used for attributes stored in a cache.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.AbstractDirectedGraph-dev-api_types","page":"Types","title":"EAGO.AbstractDirectedGraph","text":"abstract type AbstractDirectedGraph\n\nAbstract supertype for generic directed graph structure.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.AbstractEAGOConstraint-dev-api_types","page":"Types","title":"EAGO.AbstractEAGOConstraint","text":"abstract type AbstractEAGOConstraint\n\nAn abstract super-type used for representing constraints built by EAGO's backend.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.AffineFunctionEq-dev-api_types","page":"Types","title":"EAGO.AffineFunctionEq","text":"mutable struct AffineFunctionEq <: EAGO.AbstractEAGOConstraint\n\nRepresentation of an affine equality. Currently only used for bound tightening.\n\nterms::Vector{Tuple{Float64, Int64}}\nconstant::Float64\nlen::Int64\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.AffineFunctionIneq-dev-api_types","page":"Types","title":"EAGO.AffineFunctionIneq","text":"mutable struct AffineFunctionIneq <: EAGO.AbstractEAGOConstraint\n\nRepresentation of an affine inequality. Currently only used for bound tightening.\n\nterms::Vector{Tuple{Float64, Int64}}\nconstant::Float64\nlen::Int64\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.AtomType-dev-api_types","page":"Types","title":"EAGO.AtomType","text":"AtomType\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.BufferedNonlinearFunction-dev-api_types","page":"Types","title":"EAGO.BufferedNonlinearFunction","text":"mutable struct BufferedNonlinearFunction{V, N, T<:RelaxTag} <: EAGO.AbstractEAGOConstraint\n\nStores a general nonlinear function with a buffer represented by the sum of a tape and a scalar affine function.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.BufferedQuadraticEq-dev-api_types","page":"Types","title":"EAGO.BufferedQuadraticEq","text":"mutable struct BufferedQuadraticEq <: EAGO.AbstractEAGOConstraint\n\nRepresentation of a general quadratic equality constraint with a buffer.\n\nfunc::MathOptInterface.ScalarQuadraticFunction{Float64}\nminus_func::MathOptInterface.ScalarQuadraticFunction{Float64}\nbuffer::Dict{Int64, Float64}\nsaf::MathOptInterface.ScalarAffineFunction{Float64}\nlen::Int64\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.BufferedQuadraticIneq-dev-api_types","page":"Types","title":"EAGO.BufferedQuadraticIneq","text":"mutable struct BufferedQuadraticIneq <: EAGO.AbstractEAGOConstraint\n\nRepresentation of a general quadratic inequality constraint with a buffer.\n\nfunc::MathOptInterface.ScalarQuadraticFunction{Float64}\nbuffer::Dict{Int64, Float64}\nsaf::MathOptInterface.ScalarAffineFunction{Float64}\nlen::Int64\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.BufferedSOC-dev-api_types","page":"Types","title":"EAGO.BufferedSOC","text":"mutable struct BufferedSOC <: EAGO.AbstractEAGOConstraint\n\nRepresentation of a second-order cone with a buffer.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.DirectedTree-dev-api_types","page":"Types","title":"EAGO.DirectedTree","text":"DirectedTree\n\nA tree graph with a single sink node.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.EAGOParameters-dev-api_types","page":"Types","title":"EAGO.EAGOParameters","text":"mutable struct EAGOParameters\n\nStorage for parameters that do not change during a global solve.\n\npresolve_scrubber_flag::Bool: Should EAGO attempt to remove type-assert issues for user-defined functions (default = false)\npresolve_to_JuMP_flag::Bool: Create and use DAG representations of user-defined functions (default = false)\npresolve_flatten_flag::Bool: Rerrange the DAG using registered transformations (default = false)\nconic_convert_quadratic::Bool: Attempt to bridge convex constraint to second-order cone (default = false)\nlog_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)\nlog_subproblem_info::Bool: Turn on logging of times and feasibility of subproblems (default = false)\nlog_interval::Int64: Log data every log_interval iterations (default = 1)\nverbosity::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)\noutput_iterations::Int64: Display summary of iteration to console every output_iterations (default = 1000)\nheader_iterations::Int64: Display header for summary to console every output_iterations (default = 100000)\nbranch_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)\nbranch_offset::Float64: Minimum distance from bound to have branch point, normalized by width of dimension to branch on (default = 0.15)\nbranch_pseudocost_on::Bool: Indicate that pseudocost branching should be used (default = false)\nbranch_variable::Vector{Bool}: Variables to branch on (default is all nonlinear)\nbranch_max_repetitions::Int64: [FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED] Number of times to repeat node processing prior to branching (default = 4)\nbranch_repetition_tol::Float64: [FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED] Volume ratio tolerance required to repeat processing the current node (default = 0.9)\nnode_limit::Int64: Maximum number of nodes (default = 1E7)\ntime_limit::Float64: Maximum CPU time in seconds (default = 3600)\niteration_limit::Int64: Maximum number of iterations (default 1E9)\nabsolute_tolerance::Float64: Absolute tolerance for termination (default = 1E-3)\nrelative_tolerance::Float64: Relative tolerance for termination (default = 1E-3)\nabsolute_constraint_feas_tolerance::Float64: Absolute constraint feasibility tolerance (default = 1E-8)\ncp_depth::Int64: Depth in B&B tree above which constraint propagation should be disabled (default = 0)\ncp_repetitions::Int64: Number of times to repeat forward-reverse pass routine (default = 0)\ncp_tolerance::Float64: Disable constraint propagation if the ratio of new node volume to beginning node volume exceeds this number (default = 0.99)\ncp_interval_only::Bool: Use only valid interval bounds during constraint propagation (default = false)\nobbt_depth::Int64: Depth in B&B tree above which OBBT should be disabled (default = 6)\nobbt_repetitions::Int64: Number of repetitions of OBBT to perform in preprocessing (default = 3)\nobbt_aggressive_on::Bool: Turn on aggresive OBBT (default = true)\nobbt_aggressive_max_iteration::Int64: Maximum iteration to perform aggresive OBBT (default = 2)\nobbt_aggressive_min_dimension::Int64: Minimum dimension to perform aggresive OBBT (default = 2)\nobbt_tolerance::Float64: Tolerance to consider bounds equal (default = 1E-10)\nfbbt_lp_depth::Int64: Depth in B&B tree above which linear FBBT should be disabled (default = 1000)\nfbbt_lp_repetitions::Int64: Number of repetitions of linear FBBT to perform in preprocessing (default = 3)\ndbbt_depth::Int64: Depth in B&B tree above which duality-based bound tightening should be disabled (default = 1E10)\ndbbt_tolerance::Float64: New bound is considered equal to the prior bound if within dbbt_tolerance (default = 1E-8)\nrelax_tag::RelaxTag: RelaxTag used to specify type of McCormick operator (default = NS())\nsubgrad_tighten::Bool: Perform tightening of interval bounds using subgradients at each factor in each nonlinear tape during a forward pass (default = true)\nreverse_subgrad_tighten::Bool: Perform tightening of interval bounds using subgradients at each factor in each nonlinear tape during a reverse pass (default = false)\nsubgrad_tol::Float64: Outer-round computed subgradient bounds by this amount (default = 1E-10)\nmul_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)\ncut_min_iterations::Int64: Minimum number of cuts at each node to attempt (unsafe cuts not necessarily added) (default = 2)\ncut_max_iterations::Int64: Maximum number of cuts at each node to attempt (default = 8)\ncut_tolerance_abs::Float64: Absolute tolerance checked for continuing cut (default = 1E-6)\ncut_tolerance_rel::Float64: Relative tolerance checked for continuing cut (default = 1E-3)\ncut_safe_on::Bool: Use tolerances to determine safe cuts in a Khajavirad 2018 manner (default = true)\ncut_safe_l::Float64: Lower tolerance for safe-lp cut, Khajavirad 2018 (default = 1E-7)\ncut_safe_u::Float64: Upper tolerance for safe-lp cut, Khajavirad 2018 (default = 1E7)\ncut_safe_b::Float64: Constant tolerance for safe-lp cut, Khajavirad 2018 (default = 1E9)\nupper_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)\ndomain_violation_guard_on::Bool: (Unused) Protect against domain violation (default = false)\ndomain_violation_ϵ::Float64: (Unused) Amount about a domain violation to ignore when propagating bounds (default = 1E-9)\nuser_solver_config::Bool: If true, EAGO forgoes its default configuration process for subsolvers (default = false)\ninteger_abs_tol::Float64: Absolute tolerance used to check for integrality of decision variables (default = 1E-9)\ninteger_rel_tol::Float64: Relative tolerance used to check for integrality of decision variables (default = 1E-9)\nforce_global_solve::Bool: Ignore EAGO's ability to parse problem types and force it to run global optimization (default = false)\nunbounded_check::Bool: Check that all branching variables have finite bounds and set them to +/- 1E10 if not (default = true)\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.Evaluator-dev-api_types","page":"Types","title":"EAGO.Evaluator","text":"Evaluator\n\nMOI.AbstractNLPEvaluator for calculating relaxations of nonlinear terms.\n\nChecks that the resulting value should be a number.\n\nuser_operators::EAGO.OperatorRegistry\nhas_user_mv_operator::Bool\nnum_mv_buffer::Vector{Float64}\nparameter_values::Vector{Float64}\nnode::NodeBB\nvariable_values::EAGO.VariableValues{Float64}\nsubgrad_tighten::Bool\nreverse_subgrad_tighten::Bool\nsubexpressions::Vector{EAGO.NonlinearExpression}\nsubexpressions_eval::Vector{Bool}\nis_post::Bool\nis_intersect::Bool\nis_first_eval::Bool\ninterval_intersect::Bool\nsubgrad_tol::Float64\nrelax_type::EAGO.RelaxType\npass_number::Int64\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.ExtensionType-dev-api_types","page":"Types","title":"EAGO.ExtensionType","text":"abstract type ExtensionType\n\nAn 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.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.GlobalEndState-dev-api_types","page":"Types","title":"EAGO.GlobalEndState","text":"primitive type GlobalEndState <: Enum{Int32} 32\n\nAn 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.\n\nIf no call has been made to optimize!, the GlobalEndState value is:\n\nGS_UNSET: The optimization algorithm has not stated.\n\nOK\n\nGS_OPTIMAL: A globally optimal solution was found.\nGS_INFEASIBLE: The algorithm concluded that no feasible solution exists.\n\nLimits reached\n\nGS_NODE_LIMIT: The branch-and-bound algorithm stopped because it reached the user-set maximum number of nodes in the branch-and-bound tree.\nGS_ITERATION_LIMIT: The maximum number of iterations was reached.\nGS_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.\nGS_ABSOLUTE_TOL: The gap between the lower and upper bounds is within the user-set absolute tolerance.\nGS_TIME_LIMIT: The algorithm stopped after the user-specified time limit was reached.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.GlobalOptimizer-dev-api_types","page":"Types","title":"EAGO.GlobalOptimizer","text":"mutable struct GlobalOptimizer{Q, S, T<:ExtensionType} <: MathOptInterface.AbstractOptimizer\n\nOptimizer internal to EAGO which holds information used to perform branch-and-bound in order to solve nonconvex MINLPs.\n\nDescriptions of all fields available in extended help.\n\nExtended Help\n\n_subsolvers::SubSolvers{Q, S} where {Q, S}: Storage for relaxed and upper optimizers to use, and any custom extensions\n_parameters::EAGOParameters: Parameters that do not change during a global solve\n_input_problem::InputProblem: Expressions and constraints added to the EAGO model (not directly used for relaxations)\n_working_problem::ParsedProblem: Expressions and problem descriptions that EAGO uses to formulate relaxed problems\n_auxiliary_variable_info::Union{Nothing, EAGO._AuxVarData}: Information on any auxiliary variables\nobbt_variable_values::Vector{Bool}: Variables to perform OBBT on (default: all variables in nonlinear expressions)\nenable_optimize_hook::Bool: Specifies that the optimize_hook! function should be called rather than throw the problem to the standard routine\next::Any: (Deprecated, use _subsolvers instead) Storage for custom extension types\n_end_state::EAGO.GlobalEndState: The completion status code for the branch-and-bound algorithm\n_termination_status_code::MathOptInterface.TerminationStatusCode: The MathOptInterface-compliant completion status code\n_result_status_code::MathOptInterface.ResultStatusCode: Value indicating the feasibility status of the result\n_obj_mult::Float64: Multiplier used internally to convert objective sense from Max to Min. Only takes on values of {-1.0, 1.0}\n_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!)\n_stack::DataStructures.BinaryMinMaxHeap{NodeBB}: A heap of all nodes in the branch-and-bound tree\n_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\n_first_relax_point_set::Bool: (Unused) Flag for relaxation points\n_current_xref::Vector{Float64}: (Unused) Variable values of a particular point\n_candidate_xref::Vector{Float64}: (Unused) Variable values of a candidate point\n_use_prior_objective_xref::Bool: (Unused) Flag to use variable values from previous evaluation on the current step\n_current_objective_xref::Vector{Float64}: (Unused) Variable values for objective evaluation\n_prior_objective_xref::Vector{Float64}: (Unused) Variable values for previous objective evaluation\n_user_branch_variables::Bool: Flag for if the user has specified branch variables (see label_branch_variables!)\n_fixed_variable::Vector{Bool}: Variables that are fixed in place\n_branch_variable_count::Int64: Number of variables that can be branched on\n_branch_to_sol_map::Vector{Int64}: Mapping from the branch variables to the full set of variables in the problem\n_sol_to_branch_map::Vector{Int64}: Mapping from the full set of variables in the problem to the branch variables\n_continuous_solution::Vector{Float64}: The final (or intermediate) variable values of the solution\n_preprocess_feasibility::Bool: Flag to ensure preprocessing result is feasible\n_preprocess_termination_status::MathOptInterface.TerminationStatusCode: Status codes for use in bounds tightening\n_preprocess_primal_status::MathOptInterface.ResultStatusCode: Status codes for use in bounds tightening\n_preprocess_dual_status::MathOptInterface.ResultStatusCode: Status codes for use in bounds tightening\n_lower_primal_status::MathOptInterface.ResultStatusCode: Primal status of the lower problem\n_lower_dual_status::MathOptInterface.ResultStatusCode: Dual status of the lower problem\n_lower_termination_status::MathOptInterface.TerminationStatusCode: Termination status of the lower problem\n_lower_feasibility::Bool: Flag for lower problem feasibility\n_lower_objective_value::Float64: Objective value result from the lower problem\n_lower_solution::Vector{Float64}: Variable values of the lower problem solution\n_lower_lvd::Vector{Float64}: Lower variable duals for use in duality-based bound tightening\n_lower_uvd::Vector{Float64}: Upper variable duals for use in duality-based bound tightening\n_last_cut_objective::Float64: Objective value associated with the previous cut in the cutting planes algorithm\n_upper_result_status::MathOptInterface.ResultStatusCode: Primal status of the upper problem\n_upper_termination_status::MathOptInterface.TerminationStatusCode: Termination status of the upper problem\n_upper_feasibility::Bool: Flag for upper problem feasibility\n_upper_objective_value::Float64: Objective value result from the upper problem\n_upper_variables::Vector{MathOptInterface.VariableIndex}: \n_upper_solution::Vector{Float64}: \n_postprocess_feasibility::Bool: (Unused) Flag to ensure postprocessing result is feasible\n_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!\n_start_time::Float64: Storage for the time() when optimization began\n_run_time::Float64: Current run time, incremented using time()-_start_time\n_parse_time::Float64: A field to keep track of time spent on initial problem parsing\n_presolve_time::Float64: Used in optimize_nonconvex.jl to track how long the presolve step takes\n_last_preprocess_time::Float64: Updated each iteration to track the time of the preprocess step\n_last_lower_problem_time::Float64: Updated each iteration to track the time of the lower problem step\n_last_upper_problem_time::Float64: Updated each iteration to track the time of the upper problem step\n_last_postprocessing_time::Float64: Updated each iteration to track the time of the postprocess step\n_min_converged_value::Float64: A field to track convergence progress across iterations\n_global_lower_bound::Float64: The best-known lower bound\n_global_upper_bound::Float64: The best-known upper bound\n_maximum_node_id::Int64: The total number of nodes that have been created\n_iteration_count::Int64: The number of iterations the branch-and-bound algorithm has completed\n_node_count::Int64: The number of nodes in the stack\n_solution_value::Float64: (Unused) The best-known solution value\n_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\n_solution_node::Int64: The node ID of the best-known feasible upper problem solution (default = -1, if no feasible solution is found)\n_best_upper_value::Float64: The best-known upper bound\n_obbt_working_lower_index::Vector{Bool}: Indices of variables to perform OBBT on\n_obbt_working_upper_index::Vector{Bool}: Indices of variables to perform OBBT on\n_lower_indx_diff::Vector{Bool}: Tracker for changes in obbtworkinglowerindex across iterations\n_upper_indx_diff::Vector{Bool}: Tracker for changes in obbtworkingupperindex across iterations\n_old_low_index::Vector{Bool}: Storage for indices prior to OBBT step\n_old_upp_index::Vector{Bool}: Storage for indices prior to OBBT step\n_new_low_index::Vector{Bool}: New indices following OBBT step; compared with _old_low_index\n_new_upp_index::Vector{Bool}: New indices following OBBT step; compared with _old_upp_index\n_obbt_variables::Vector{MathOptInterface.VariableIndex}: (Deprecated) Variables to perform OBBT on. Replaced by _obbt_working_lower_index and _obbt_working_upper_index\n_obbt_variable_count::Int64: The number of variables to perform OBBT on\n_obbt_performed_flag::Bool: (Unused) Flag to indicate whether OBBT has been performed\n_lower_fbbt_buffer::Vector{Float64}: Buffer for FBBT lower bounds. Set in presolve, used in preprocess\n_upper_fbbt_buffer::Vector{Float64}: Buffer for FBBT upper bounds. Set in presolve, used in preprocess\n_cp_improvement::Float64: (Unused) Improvement in constraint propagation\n_cp_evaluation_reverse::Bool: (Unused) Flag for if constraint propagation results need to be reversed\n_cut_iterations::Int64: Iterations of the cutting planes algorithm completed\n_cut_add_flag::Bool: (Unused) Flag to check if cuts should be added\n_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\n_log::Log: Storage for logging information during a branch-and-bound run\n_affine_relax_ci::Vector{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}}: Storage for affine constraints\n_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\n_relaxed_variable_number::Int64: (Unused) Number of relaxed variables\n_relaxed_variable_index::Vector{MathOptInterface.VariableIndex}: Indices of relaxed variables\n_relaxed_variable_et::Vector{Tuple{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.EqualTo{Float64}}, Int64}}: Stored EqualTo constraints\n_relaxed_variable_lt::Vector{Tuple{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}, Int64}}: Stored LessThan constraints\n_relaxed_variable_gt::Vector{Tuple{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}, Int64}}: Stored GreaterThan constraints\n_relaxed_variable_integer::Vector{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.Integer}}: Stored Integer constraints\n_branch_variables::Vector{Bool}: List of variables that can be branched on. If not user-specified, branch variables are identified in label_branch_variables!\n_nonbranching_int::Bool: (Unused) Flag for non-branching integers\n_new_eval_constraint::Bool: Flag indicating if an initial evaluation of the constraints has occurred\n_new_eval_objective::Bool: Flag indicating if the objective expression was evaluated\n_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!\n_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!\n_nonlinear_evaluator_created::Bool: Flag to check for nonlinear evaluators. Set to true in add_nonlinear_evaluator!\n_branch_cost::EAGO.BranchCostStorage{Float64}: (FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED) Storage for pseudocost branching\n_branch_variable_sparsity::SparseArrays.SparseMatrixCSC{Bool, Int64}: (FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED) Sparsity information of the branch variables\n_constraint_infeasiblity::Vector{Float64}: (FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED) Information on the infeasibility of each constraint\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.Incremental-dev-api_types","page":"Types","title":"EAGO.Incremental","text":"mutable struct Incremental{S<:MathOptInterface.AbstractOptimizer} <: MathOptInterface.AbstractOptimizer\n\nA 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. \n\n(Deprecated) For Q = Val{true}, the subsolver supports incremental loading. For Q = Val{false}, the subsolver does not.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.InputProblem-dev-api_types","page":"Types","title":"EAGO.InputProblem","text":"mutable struct InputProblem\n\nA structure used to hold objectives and constraints added to the EAGO model. The constraints generally aren't used for relaxations.\n\nAll field information available in extended help.\n\nExtended Help\n\n_variable_count::Int64: Count for the number of variables\n_variable_names::Dict{MathOptInterface.VariableIndex, String}: Dictionary containing variable indices and their names\n_constraint_count::Int64: Count for the number of constraints\n_vi_leq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}}\n_vi_geq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}}\n_vi_eq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.EqualTo{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.EqualTo{Float64}}}\n_vi_it_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.Interval{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.Interval{Float64}}}\n_vi_zo_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.ZeroOne}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.ZeroOne}}\n_vi_int_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.Integer}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.Integer}}\n_linear_leq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, Tuple{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}}\n_linear_geq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Tuple{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}\n_linear_eq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Tuple{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}}\n_quadratic_leq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}, Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}}\n_quadratic_geq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}\n_quadratic_eq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}}\n_conic_second_order::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VectorOfVariables, MathOptInterface.SecondOrderCone}, Tuple{MathOptInterface.VectorOfVariables, MathOptInterface.SecondOrderCone}}\n_linear_leq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, Float64}\n_linear_geq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Float64}\n_linear_eq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Float64}\n_quadratic_leq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}, Float64}\n_quadratic_geq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Float64}\n_quadratic_eq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Float64}\n_linear_leq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}}\n_linear_geq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}\n_linear_eq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}}\n_quadratic_leq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}}\n_quadratic_geq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}\n_quadratic_eq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}}\n_objective::Union{Nothing, MathOptInterface.VariableIndex, MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.ScalarQuadraticFunction{Float64}}: Storage for the objective function\n_nlp_data::Union{Nothing, MathOptInterface.NLPBlockData}: Storage for NLP constraints (set by MOI.set(m, ::NLPBlockData...) in moi_wrapper.jl)\n_optimization_sense::MathOptInterface.OptimizationSense: Objective sense information (set by MOI.set(m, ::ObjectiveSense...))\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.LocalResultStatus-dev-api_types","page":"Types","title":"EAGO.LocalResultStatus","text":"LocalResultStatus\n\nStatus code used internally to determine how to interpret the results from the solution of a local problem solve.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.Log-dev-api_types","page":"Types","title":"EAGO.Log","text":"mutable struct Log\n\nA structure used to store information on the history of the solution procedure for generating convergence plots and other analyses.\n\ncurrent_lower_bound::Vector{Float64}: Storage for lower bound calculated for current node.\ncurrent_upper_bound::Vector{Float64}: Storage for upper bound calculated for current node.\npreprocessing_time::Vector{Float64}: Storage for preprocessing time of each iteration.\nlower_problem_time::Vector{Float64}: Storage for lower bounding time of each iteration.\nupper_problem_time::Vector{Float64}: Storage for upper bounding time of each iteration.\npostprocessing_time::Vector{Float64}: Storage for postprocessing time of each iteration.\npreprocessing_feas::Vector{Bool}: Storage for preprocessing feasibility of each iteration.\nlower_problem_feas::Vector{Bool}: Storage for lower bounding feasibility of each iteration.\nupper_problem_feas::Vector{Bool}: Storage for upper bounding feasibility of each iteration.\npostprocessing_feas::Vector{Bool}: Storage for postprocessing feasibility of each iteration.\nglobal_lower_bound::Vector{Float64}: Storage for best (global) lower bound at each iteration.\nglobal_upper_bound::Vector{Float64}: Storage for best (global) upper bound at each iteration.\nnode_count::Vector{Int64}: Number of nodes at each iteration.\nrun_time::Vector{Float64}: Run time at each iteration.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.Node-dev-api_types","page":"Types","title":"EAGO.Node","text":"struct Node <: EAGO.AbstractNode\n\nDescribes connectivity and expression represented by node.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.NodeBB-dev-api_types","page":"Types","title":"EAGO.NodeBB","text":"struct NodeBB\n\nStore information associated with each node in the branch-and-bound tree.\n\nlower_variable_bounds::Vector{Float64}: Lower bounds of variable box.\nupper_variable_bounds::Vector{Float64}: Upper bounds of variable box.\nis_integer::BitVector: Is dimension integer valued\ncontinuous::Bool: Are all dimensions continuous (or fixed)\nlower_bound::Float64: Lower bound of problem solution on nodeBB\nupper_bound::Float64: Upper bound of problem solution on nodeBB\ndepth::Int64: Depth of node in B&B tree.\ncont_depth::Int64: Depth of first parent in B&B tree that was continuously valued\nid::Int64: Unique ID for each node.\nbranch_direction::EAGO.BranchDirection: Whether last branch was negative or positive in direction\nlast_branch::Int64: Dimension of last branch\nbranch_extent::Float64: Extent of last branch (using for psuedocost calculation)\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.NodeClass-dev-api_types","page":"Types","title":"EAGO.NodeClass","text":"NodeType\n\nEach node in the directed graph can be classified into the following types\n\nVARIABLE: Denotes a decision variable.\nPARAMETER: An adjustable parameter value (not a decision variable).\nCONSTANT: A constant value\nEXPRESSION: Any other expression that isn't a subexpression\nSUBEXPRESSION: Any expression referencing a different graph representation.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.NonlinearExpression-dev-api_types","page":"Types","title":"EAGO.NonlinearExpression","text":"mutable struct NonlinearExpression{V, N, T<:RelaxTag} <: EAGO.AbstractEAGOConstraint\n\nStores a general quadratic function with a buffer.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.Optimizer-dev-api_types","page":"Types","title":"EAGO.Optimizer","text":"mutable struct Optimizer{Q, S, T} <: MathOptInterface.AbstractOptimizer\n\nThe 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:\n\nrelaxed_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}.\nupper_optimizer::MOI.AbstractOptimizer: Optimizer used to solve upper bounding problems (default = Ipopt.Optimizer()). Located in subsolver_block::SubSolvers{Q,S,T}.\next::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}.\nenable_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}.\nobbt_variable_values::Vector{Bool}: Variables to perform OBBT on (default: all variables in nonlinear expressions). Located in _global_optimizer::GlobalOptimizer{Q,S,T}.\n\nDescriptions of all Optimizer fields available in extended help.\n\nExtended Help\n\nsubsolver_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\nenable_optimize_hook::Bool: Specifies that the optimize_hook! function should be called rather than throw the problem to the standard routine\next::Union{Nothing, T} where T: (Deprecated, use subsolver_block instead) Storage for custom extension types\n_auxiliary_variable_info::Union{Nothing, EAGO._AuxVarData}: Information on any auxiliary variables\n_global_optimizer::GlobalOptimizer{Q, S, T} where {Q, S, T}: Additional options and temporary storage for solving optimization problems\n_input_problem::InputProblem: Expressions and constraints added to the EAGO model (not directly used for relaxations)\n_working_problem::ParsedProblem: Expressions and problem descriptions that EAGO uses to formulate relaxed problems\n_parameters::EAGOParameters: Parameters that do not change during a global solve\n_optimizer_attributes_set::Vector{MathOptInterface.AbstractOptimizerAttribute}: Set of optimizer attributes\n_termination_status_code::MathOptInterface.TerminationStatusCode: The MathOptInterface-compliant completion status code\n_result_status_code::MathOptInterface.ResultStatusCode: Value indicating the feasibility status of the result\n_run_time::Float64: Optimization run time\n_objective_value::Float64: The objective value of the primal solution\n_objective_bound::Float64: The best-known bound on the optimal objective value\n_relative_gap::Float64: The gap between the upper and lower bound, relative to the bound with the larger magnitude\n_iteration_count::Int64: The number of iterations the branch-and-bound algorithm has completed\n_node_count::Int64: The number of nodes in the stack\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.ParsedProblem-dev-api_types","page":"Types","title":"EAGO.ParsedProblem","text":"mutable struct ParsedProblem\n\nA structure used to store expressions and problem descriptions EAGO uses to formulate relaxed problems.\n\nAll field information available in extended help.\n\nExtended Help\n\n_problem_type::Union{Nothing, EAGO.DIFF_CVX, EAGO.LP, EAGO.MILP, EAGO.MINCVX, EAGO.MISOCP, EAGO.SOCP}: Problem classification (set in parse_classify_problem!)\n_objective_saf::MathOptInterface.ScalarAffineFunction{Float64}: Stores the objective and is used for constructing linear affine cuts\n_objective::Union{Nothing, MathOptInterface.VariableIndex, EAGO.AffineFunctionIneq, EAGO.BufferedQuadraticIneq, EAGO.BufferedNonlinearFunction}: Storage for the objective function\n_optimization_sense::MathOptInterface.OptimizationSense: Objective sense information (set by MOI.set(m, ::ObjectiveSense...))\n_saf_leq::Vector{EAGO.AffineFunctionIneq}\n_saf_eq::Vector{EAGO.AffineFunctionEq}\n_sqf_leq::Vector{EAGO.BufferedQuadraticIneq}\n_sqf_eq::Vector{EAGO.BufferedQuadraticEq}\n_conic_second_order::Vector{EAGO.BufferedSOC}\n_nlp_data::Union{Nothing, MathOptInterface.NLPBlockData}\n_nonlinear_constr::Vector{EAGO.BufferedNonlinearFunction}\n_relaxed_evaluator::Evaluator\n_variable_info::Vector{VariableInfo{Float64}}: Variable information (set in initial_parse!)\n_variable_count::Int64: Count for the number of variables\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.Relax-dev-api_types","page":"Types","title":"EAGO.Relax","text":"Relax\n\nUsed to dispatch relaxations to a standard \n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.RelaxAA-dev-api_types","page":"Types","title":"EAGO.RelaxAA","text":"RelaxAA\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.RelaxMulEnum-dev-api_types","page":"Types","title":"EAGO.RelaxMulEnum","text":"RelaxMulEnum\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.RelaxResultStatus-dev-api_types","page":"Types","title":"EAGO.RelaxResultStatus","text":"RelaxResultStatus\n\nStatus code used internally to determine how to interpret the results from the solution of a relaxed problem.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.SIPHybrid-dev-api_types","page":"Types","title":"EAGO.SIPHybrid","text":"SIPHybrid\n\nSpecifies 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.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.SIPProblem-dev-api_types","page":"Types","title":"EAGO.SIPProblem","text":" SIPProblem\n\nStructure storing problem information for the solution routine.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.SIPRes-dev-api_types","page":"Types","title":"EAGO.SIPRes","text":"SIPRes\n\nSpecifies 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.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.SIPResRev-dev-api_types","page":"Types","title":"EAGO.SIPResRev","text":"SIPResRev\n\nSpecifies 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.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.SIPResult-dev-api_types","page":"Types","title":"EAGO.SIPResult","text":"SIPResult\n\nStructure storing the results of the SIPRes algorithm.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.SIPSubResult-dev-api_types","page":"Types","title":"EAGO.SIPSubResult","text":"SIPBuffer\n\nHold objective value, solution, discretization set, and feasibility status of each subproblem encountered by SIP algorithm.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.SubSolvers-dev-api_types","page":"Types","title":"EAGO.SubSolvers","text":"mutable struct SubSolvers{Q<:MathOptInterface.AbstractOptimizer, S<:MathOptInterface.AbstractOptimizer, T<:ExtensionType}\n\nA structure containing the relaxed and upper optimizers to be used, as well as any user-defined extension.\n\nrelaxed_optimizer::MathOptInterface.AbstractOptimizer: Optimizer used to solve relaxed subproblems. Set using r = [...] (<: MOI.AbstractOptimizer) (default = Cbc.Optimizer())\nupper_optimizer::MathOptInterface.AbstractOptimizer: Optimizer used to solve upper bounding problems. Set using u = [...] (<: MOI.AbstractOptimizer) (default = Ipopt.Optimizer())\next::ExtensionType: User-defined extension to use. Set using t = [...](<: EAGO.ExtensionType)\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.VariableInfo-dev-api_types","page":"Types","title":"EAGO.VariableInfo","text":"struct VariableInfo{T<:AbstractFloat}\n\nA structure used to store information related to the bounds assigned to each variable.\n\nis_integer::Bool: Is the variable integer valued?\nhas_lower_bound::Bool: Boolean indicating whether a finite lower bound exists.\nhas_upper_bound::Bool: Boolean indicating whether a finite upper bound exists.\nis_fixed::Bool: Boolean indicating if variable is fixed to a finite value.\nhas_constraints::Bool: Boolean indicating that constraints have been set\nlower_bound::AbstractFloat: Lower bound. May be -Inf.\nupper_bound::AbstractFloat: Upper bound. May be Inf.\n\n\n\n\n\n","category":"type"},{"location":"examples/quasiconvex/#Advanced-Use-Example-1","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"","category":"section"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"This example is also provided here as a Jupyter Notebook.","category":"page"},{"location":"examples/quasiconvex/#Customizing-EAGO-to-Solve-a-Quasiconvex-Problem","page":"Advanced-Use Example 1","title":"Customizing EAGO to Solve a Quasiconvex Problem","text":"","category":"section"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"In this example, we'll adapt EAGO to implement the bisection-based algorithm used to solve a quasiconvex optimization problem presented in [1]:","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"beginaligned\nf^* = min_mathbf y in Y f(mathbf y) \nrm st sum_i = 1^5 i cdot y_i - 5 = 0 \n sum_i = 1^5 y_i^2 - 05 pi leq 0 \n -bigg(frac12 y_1^2 + frac12 y_2^2 + 2 y_1 y_2 + 4 y_1 y_3 + 2 y_2 y_3 bigg) leq 0 \n -y_1^2 - 6 y_1 y_2 - 2 y_2^2 + cos (y_1) + pi leq 0 \n Y = 0 5^5\nendaligned","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"where","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"beginaligned\nf(mathbf y) = -fracln ((5 + y_1)^2 + sum_i = 1^5 y_i)1 + sum_i = 1^5 y_i^2\nendaligned","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"Interval analysis shows that the objective value is bounded by the interval F such that f^* in F = f^L f^U = -5 0. Introducing an auxiliary variable t in T = F allows the problem to be formulated as:","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"beginaligned\nt^* = min_mathbf y in Y t in T t \nrm st (24) - (27) \n f(mathbf y) - t leq 0 \n Y = 05^2 T = -50\nendaligned","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"Let phi_tau(mathbf y) = f(mathbf y) - tau such that tau = (t^L + t^U)2. We solve for mathbf y subject to constraints (24) - (27) where phi_tau (mathbf y) leq 0. If this is feasible, t^* in t^Ltau, else t^* in τ t^U. The interval containing t^* is kept and the other is fathomed. This manner of bisection is repeated until an interval containing a feasible solution with a width of at most epsilon is located [2].","category":"page"},{"location":"examples/quasiconvex/#Customizing-EAGO's-Script","page":"Advanced-Use Example 1","title":"Customizing EAGO's Script","text":"","category":"section"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"First, the preprocessing step, upper problem, and postprocessing routines are short-circuited as only a single optimization problem needs to be solved at each iteration.","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"using MathOptInterface, EAGO, JuMP\nimport EAGO: Optimizer, GlobalOptimizer\n\nstruct QuasiConvex <: EAGO.ExtensionType end\nimport EAGO: preprocess!, upper_problem!, postprocess!\nfunction EAGO.preprocess!(t::QuasiConvex, x::GlobalOptimizer)\n x._preprocess_feasibility = true\nend\nfunction EAGO.upper_problem!(t::QuasiConvex, x::GlobalOptimizer)\n x._upper_feasibility = true\nend\nfunction EAGO.postprocess!(t::QuasiConvex, x::GlobalOptimizer)\n x._postprocess_feasibility = true\nend","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"Next, we specify that only an absolute tolerance should be checked for convergence and termination.","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"import EAGO: convergence_check, termination_check\nfunction EAGO.convergence_check(t::QuasiConvex, x::GlobalOptimizer)\n gap = (x._upper_objective_value - x._lower_objective_value)\n return (gap <= x._parameters.absolute_tolerance)\nend\nfunction EAGO.termination_check(t::QuasiConvex, x::GlobalOptimizer)\n flag = EAGO.convergence_check(t, x)\n if flag\n x._end_state = EAGO.GS_OPTIMAL\n x._termination_status_code = MathOptInterface.OPTIMAL\n x._result_status_code = MathOptInterface.FEASIBLE_POINT\n end\n return flag\nend","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"We then indicate that only the sixth variable, representing t, should be branched on. Since we will apply our knowledge about which t^* should be kept in the lower problem definition, we also short-circuit the EAGO.repeat_check function here to tell EAGO not to branch this node, but instead to repeatedly evaluate it.","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"import EAGO: repeat_check\nbranch_variable = [i == 6 for i=1:6]\nEAGO.repeat_check(t::QuasiConvex, x::GlobalOptimizer) = true","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"In the lower problem, we then specify that the problem is to be solved locally for a fixed t value. The objective value is then updated and the problem is contracted in order to discard the region which is known to not contain the optimal value.","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"import EAGO: lower_problem!\nfunction EAGO.lower_problem!(t::QuasiConvex, x::GlobalOptimizer)\n y = x._current_node\n indx = x._sol_to_branch_map[6]\n lower = y.lower_variable_bounds[indx]\n upper = y.upper_variable_bounds[indx]\n midy = (lower + upper)/2.0\n y.lower_variable_bounds[indx] = midy\n y.upper_variable_bounds[indx] = midy\n EAGO.solve_local_nlp!(x)\n feas = x._upper_feasibility\n y.lower_variable_bounds[indx] = feas ? lower : midy\n y.upper_variable_bounds[indx] = feas ? midy : upper\n x._lower_objective_value = y.lower_variable_bounds[indx]\n x._upper_objective_value = y.upper_variable_bounds[indx]\n x._lower_feasibility = true\n return\nend","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"We now define the optimizer factory to extend the core EAGO optimizer for this special problem. The SubSolvers constructor is used to set the extension type (t), as well as the relaxed optimizer (r) and upper-bounding optimizer (u), if necessary. In this case, we will use the default solvers and only set the extension type.","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"factory = () -> Optimizer(SubSolvers(; t = QuasiConvex()))","category":"page"},{"location":"examples/quasiconvex/#Construct-the-JuMP-Model-and-Optimize","page":"Advanced-Use Example 1","title":"Construct the JuMP Model and Optimize","text":"","category":"section"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"We now build the JuMP [3] model representing this problem, solve it, and retrieve the solution.","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"opt = optimizer_with_attributes(factory, \n \"absolute_tolerance\" => 1E-8, \n \"branch_variable\" => branch_variable,\n \"iteration_limit\" => 1000)\nm = Model(opt)\n@variable(m, ((i<6) ? 0.0 : -5.0) <= y[i=1:6] <= ((i<6) ? 5.0 : 0.0))\n@constraint(m, sum(i*y[i] for i=1:5) - 5.0 == 0.0)\n@constraint(m, sum(y[i]^2 for i=1:5) - 0.5*pi^2 <= 0.0)\n@expression(m, expr1, 2.0*y[1]*y[2] + 4.0*y[1]*y[3] + 2.0*y[2]*y[3])\n@constraint(m, -(0.5*y[1]^2 + 0.5*y[2]^2 + y[3]^2 + expr1) <= 0.0)\n@NLexpression(m, expr2, log((5.0 + y[1])^2 + sum(y[i] for i=1:5)))\n@NLconstraint(m, -y[1]^2 - 6.0*y[1]*y[2] - 2.0*y[2]^2 + cos(y[1]) + pi <= 0.0)\n@NLconstraint(m, -expr2/(1.0 + sum(y[i]^2 for i=1:5)) - y[6] <= 0.0)\n@objective(m, Min, y[6])\n\nJuMP.optimize!(m)","category":"page"},{"location":"examples/quasiconvex/#Retrieve-Results","page":"Advanced-Use Example 1","title":"Retrieve Results","text":"","category":"section"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"We then recover the solution values and the objective value using standard JuMP syntax.","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"solution = JuMP.value.(y[1:5])\nglobal_obj_value = JuMP.value.(y[6])\nprint(\"Global solution at y*=$solution with a value of f*=$global_obj_value\")","category":"page"},{"location":"examples/quasiconvex/#References","page":"Advanced-Use Example 1","title":"References","text":"","category":"section"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"C. Jansson, Quasiconvex relaxations based on interval arithmetic, Linear Algebra and its Applications, 324 (2001), pp. 27–53.\nS. Boyd and L. Vandenberghe, Convex optimization, Cambridge University Press, 2004.\nIain Dunning and Joey Huchette and Miles Lubin. JuMP: A Modeling Language for Mathematical Optimization, SIAM Review, 59 (2017), pp. 295-320.","category":"page"},{"location":"semiinfinite/semiinfinite/#Solving-Semi-Infinite-Programs","page":"Semi-Infinite Programming","title":"Solving Semi-Infinite Programs","text":"","category":"section"},{"location":"semiinfinite/semiinfinite/#Using-EAGO-to-Solve-a-Semi-Infinite-Program","page":"Semi-Infinite Programming","title":"Using EAGO to Solve a Semi-Infinite Program","text":"","category":"section"},{"location":"semiinfinite/semiinfinite/","page":"Semi-Infinite Programming","title":"Semi-Infinite Programming","text":"This example is also provided here as a Jupyter Notebook.","category":"page"},{"location":"semiinfinite/semiinfinite/","page":"Semi-Infinite Programming","title":"Semi-Infinite Programming","text":"Semi-infinite programming remains an active area of research. In general, the solutions of semi-infinite programs (SIPs) with nonconvex semi-infinite constraints of the following form are extremely challenging:","category":"page"},{"location":"semiinfinite/semiinfinite/","page":"Semi-Infinite Programming","title":"Semi-Infinite Programming","text":"beginaligned\nf^* = min_mathbf x in X f(mathbf x) \nrm st g(mathbf x mathbf p) leq 0 forall mathbf p in P \n mathbf x in X = mathbf x in mathbb R^n_x mathbf x^L leq mathbf x leq mathbf x^U \n P = mathbf p in mathbb R^n_p mathbf p^L leq mathbf p leq mathbf p^U \nendaligned","category":"page"},{"location":"semiinfinite/semiinfinite/","page":"Semi-Infinite Programming","title":"Semi-Infinite Programming","text":"EAGO implements three different algorithms detailed in [1, 2] to determine a globally optimal solution to problems of the above form. This is accomplished using the sip_solve function which returns the optimal value, the solution, and a boolean feasibility flag. To illustrate the use of this function, a simple example is presented here which solves the problem:","category":"page"},{"location":"semiinfinite/semiinfinite/","page":"Semi-Infinite Programming","title":"Semi-Infinite Programming","text":"beginaligned\nf(mathbf x) = frac13 x_1^2 + x_2^2 + fracx_12 \ng(mathbf x p) = (1 - x_1^2 p^2)^2 - x_1 p^2 - x_2^2 + x_2 leq 0 \n mathbf x in X = -1000 1000^2 \n p in P = 0 1\nendaligned","category":"page"},{"location":"semiinfinite/semiinfinite/","page":"Semi-Infinite Programming","title":"Semi-Infinite Programming","text":"using EAGO, JuMP\n\n# Define semi-infinite program\nf(x) = (1/3)*x[1]^2 + x[2]^2 + x[1]/2\ngSIP(x, p) = (1.0 - x[1]^2*p[1]^2)^2 - x[1]*p[1]^2 - x[2]^2 + x[2]\n\nx_l = Float64[-1000.0, -1000.0]\nx_u = Float64[1000.0, 1000.0]\np_l = Float64[0.0]\np_u = Float64[1.0]\n\nsip_result = sip_solve(SIPRes(), x_l, x_u, p_l, p_u, f, Any[gSIP], res_sip_absolute_tolerance = 1E-3);","category":"page"},{"location":"semiinfinite/semiinfinite/#Semi-Infinite-Solver","page":"Semi-Infinite Programming","title":"Semi-Infinite Solver","text":"","category":"section"},{"location":"semiinfinite/semiinfinite/","page":"Semi-Infinite Programming","title":"Semi-Infinite Programming","text":" SIPProblem\n SIPResult\n SIPRes\n SIPResRev\n SIPHybrid\n get_sip_optimizer\n build_model\n sip_llp!\n sip_bnd!\n sip_res!\n sip_solve","category":"page"},{"location":"semiinfinite/semiinfinite/#EAGO.SIPProblem","page":"Semi-Infinite Programming","title":"EAGO.SIPProblem","text":" SIPProblem\n\nStructure storing problem information for the solution routine.\n\n\n\n\n\n","category":"type"},{"location":"semiinfinite/semiinfinite/#EAGO.SIPResult","page":"Semi-Infinite Programming","title":"EAGO.SIPResult","text":"SIPResult\n\nStructure storing the results of the SIPRes algorithm.\n\n\n\n\n\n","category":"type"},{"location":"semiinfinite/semiinfinite/#EAGO.SIPRes","page":"Semi-Infinite Programming","title":"EAGO.SIPRes","text":"SIPRes\n\nSpecifies 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.\n\n\n\n\n\n","category":"type"},{"location":"semiinfinite/semiinfinite/#EAGO.SIPResRev","page":"Semi-Infinite Programming","title":"EAGO.SIPResRev","text":"SIPResRev\n\nSpecifies 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.\n\n\n\n\n\n","category":"type"},{"location":"semiinfinite/semiinfinite/#EAGO.SIPHybrid","page":"Semi-Infinite Programming","title":"EAGO.SIPHybrid","text":"SIPHybrid\n\nSpecifies 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.\n\n\n\n\n\n","category":"type"},{"location":"semiinfinite/semiinfinite/#EAGO.get_sip_optimizer","page":"Semi-Infinite Programming","title":"EAGO.get_sip_optimizer","text":"get_sip_optimizer\n\nSpecifices the optimizer to be used in extension t::EAGO.ExtensionType with algorithm alg::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command get_sip_optimizer(t::ExtensionType, alg::AbstractSIPAlgo, s::AbstractSubproblemType).\n\n\n\n\n\n","category":"function"},{"location":"semiinfinite/semiinfinite/#EAGO.build_model","page":"Semi-Infinite Programming","title":"EAGO.build_model","text":"build_model\n\nCreate the model and variables used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command build_model(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, p::SIPProblem).\n\n\n\n\n\n","category":"function"},{"location":"semiinfinite/semiinfinite/#EAGO.sip_llp!","page":"Semi-Infinite Programming","title":"EAGO.sip_llp!","text":"sip_llp!\n\nSolves the lower level problem for the ith-SIP used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_llp!(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, ..., i, tol).\n\n\n\n\n\n","category":"function"},{"location":"semiinfinite/semiinfinite/#EAGO.sip_bnd!","page":"Semi-Infinite Programming","title":"EAGO.sip_bnd!","text":"sip_bnd!\n\nSolves the bounding problem for the ith-SIP used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_bnd!(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, ..., i, tol).\n\n\n\n\n\n","category":"function"},{"location":"semiinfinite/semiinfinite/#EAGO.sip_res!","page":"Semi-Infinite Programming","title":"EAGO.sip_res!","text":"sip_res!\n\nSolves the restriction problem for extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_res!(t::ExtensionType, a::AbstractSIPAlgo, ...).\n\n\n\n\n\n","category":"function"},{"location":"semiinfinite/semiinfinite/#EAGO.sip_solve","page":"Semi-Infinite Programming","title":"EAGO.sip_solve","text":"sip_solve\n\nSolve an SIP with decision variable bounds x_l to x_u, uncertain variable bounds p_l to p_u, an objective function of f, and gSIP seminfiniite constraint(s).\n\n\n\n\n\n","category":"function"},{"location":"semiinfinite/semiinfinite/#References","page":"Semi-Infinite Programming","title":"References","text":"","category":"section"},{"location":"semiinfinite/semiinfinite/","page":"Semi-Infinite Programming","title":"Semi-Infinite Programming","text":"Mitsos A (2009). Global optimization of semi-infinite programs via restriction of the right-hand side. Optimization, 60(10-11):1291-1308.\nDjelassi, 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.","category":"page"},{"location":"examples/interval_bb/#Standard-Use-Example-2","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"This example is also provided here as a Jupyter Notebook.","category":"page"},{"location":"examples/interval_bb/#Using-EAGO's-Basic-Optimizer-With-User-Defined-Subroutines","page":"Standard-Use Example 2","title":"Using EAGO's Basic Optimizer With User-Defined Subroutines","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"In this section, we construct an optimizer that uses EAGO's basic NLP solution routine with user-defined lower and upper-bounding problems. The Optimizer structure supplies a number of parameters and stored structures that advanced users may find useful for constructing specialized solution routines.","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"In this example, we'll forgo extensive integration into the Optimizer and simply replace the lower and upper-bounding problems to construct a B&B routine that solves the following problem to global optimality using bounds obtained from interval arithmetic:","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"beginaligned\n min_mathbf x in X sin(x_1) x_2^2 - cos(x_3) x_4 \n X = -10 10 times -1 1 times -10 10 times 2 20\nendaligned","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"We begin by importing EAGO, IntervalArithmetic [1], and JuMP [2].","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"using EAGO, IntervalArithmetic, JuMP","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"We now define the IntervalExt struct as a subtype of the ExtensionType.","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"struct IntervalExt <: EAGO.ExtensionType end","category":"page"},{"location":"examples/interval_bb/#Define-a-Custom-Lower-Bounding-Problem","page":"Standard-Use Example 2","title":"Define a Custom Lower-Bounding Problem","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"A valid lower bound is obtained from the lower bound of the natural interval extension using the IntervalArithmetic.jl [1] package. The LowerProblem is dispatched using the new IntervalExt structure and the GlobalOptimizer structure, computes the bound using interval arithmetic, and stores the results to the appropriate field of the GlobalOptimizer. Note that the problem is unconstrained on the domain so we can assume it is always feasible. Further, since the interval bound is constrained along the entire domain associated with a node, no additional cuts will be beneficial and thus we've disabled them using the _cut_add_flag field.","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"import EAGO: lower_problem!\nfunction lower_problem!(t::IntervalExt, x::EAGO.GlobalOptimizer)\n # Retrieve bounds at current node\n n = x._current_node\n lower = n.lower_variable_bounds\n upper = n.upper_variable_bounds\n \n # Define X for the node and compute the interval extension\n x_value = Interval.(lower, upper)\n F = sin(x_value[1])*x_value[2]^2 - cos(x_value[3])/x_value[4]\n x._lower_objective_value = F.lo\n x._lower_solution = IntervalArithmetic.mid.(x_value)\n x._lower_feasibility = true\n x._cut_add_flag = false\n \n return\nend","category":"page"},{"location":"examples/interval_bb/#Define-a-Custom-Upper-Bounding-Problem","page":"Standard-Use Example 2","title":"Define a Custom Upper-Bounding Problem","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"Since the problem is unconstrained, any feasible point represents a valid upper bound. Thus, if we arbitrarily evaluate the function at the midpoint, we obtain a valid upper bound. This function constructs an upper bound in this manner then stores the results to the appropriate field of the GlobalOptimizer.","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"import EAGO.upper_problem!\nfunction EAGO.upper_problem!(t::IntervalExt, x::EAGO.GlobalOptimizer)\n # Retrieve bounds at current node\n n = x._current_node\n lower = n.lower_variable_bounds\n upper = n.upper_variable_bounds\n \n # Compute midpoint value and evaluate at that point\n x_value = 0.5*(upper + lower)\n f_val = sin(x_value[1])*x_value[2]^2-cos(x_value[3])/x_value[4]\n x._upper_objective_value = f_val\n x._upper_solution = x_value\n x._upper_feasibility = true\n \n return\nend","category":"page"},{"location":"examples/interval_bb/#Disable-Unnecessary-Routines","page":"Standard-Use Example 2","title":"Disable Unnecessary Routines","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"It is entirely possible to disable domain reduction by manipulating keyword arguments supplied to the optimizer. However, for simplicity's sake we'll simply overload the default preprocessing and postprocessing methods and indicate that there are no conditions under which EAGO should cut the node.","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"import EAGO: preprocess!, postprocess!, cut_condition\nfunction EAGO.preprocess!(t::IntervalExt, x::EAGO.GlobalOptimizer)\n x._preprocess_feasibility = true\n return\nend\nfunction EAGO.postprocess!(t::IntervalExt, x::EAGO.GlobalOptimizer)\n x._postprocess_feasibility = true\n return\nend\nEAGO.cut_condition(t::IntervalExt, x::EAGO.GlobalOptimizer) = false","category":"page"},{"location":"examples/interval_bb/#Construct-the-JuMP-Model-and-Optimize","page":"Standard-Use Example 2","title":"Construct the JuMP Model and Optimize","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"We now add our optimizer to a JuMP [2] model, provide variable bounds, and optimize.","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"# Create a factory that specifies the interval extension in EAGO's SubSolver\nfactory = () -> EAGO.Optimizer(SubSolvers(; t = IntervalExt()))\n\n# Create a JuMP model using the factory, and with the absolute tolerance set by keyword argument\nm = Model(optimizer_with_attributes(factory,\n \"absolute_tolerance\" => 0.001\n ))\n\n# Add variables, bounds, and the objective function\nx_L = [-10.0, -1.0, -10.0, 2.0]\nx_U = [10.0, 1.0, 10.0, 20.0]\n@variable(m, x_L[i] <= x[i=1:4] <= x_U[i])\n@NLobjective(m, Min, sin(x[1])*x[2]^2 - cos(x[3])/x[4])\n\n# Perform the optimization\noptimize!(m)","category":"page"},{"location":"examples/interval_bb/#Retrieve-Results","page":"Standard-Use Example 2","title":"Retrieve Results","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"The objective value, solution, termination status, and primal status can then be accessed via the standard JuMP interface.","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"fval = JuMP.objective_value(m)\nxsol = JuMP.value.(x)\nstatus_term = JuMP.termination_status(m)\nstatus_prim = JuMP.primal_status(m)\n\nprintln(\"EAGO terminated with a status of $status_term and a result code of $status_prim\")\nprintln(\"The optimal value is: $(round(fval, digits=3)), the solution found is $(round.(xsol, digits=4)).\")","category":"page"},{"location":"examples/interval_bb/#Advice-for-More-Advanced-Constructions","page":"Standard-Use Example 2","title":"Advice for More Advanced Constructions","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"The default lower_problem! and upper_problem! should be used as templates for error handling and retrieving information from MOI models.","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"Essentially all of EAGO's subroutines stored to a field in the Optimizer structure can be reset as user-defined functions.","category":"page"},{"location":"examples/interval_bb/#References","page":"Standard-Use Example 2","title":"References","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"IntervalArithmetic.jl [Computer software] (2019). Retrieved from https://github.com/JuliaIntervals/IntervalArithmetic.jl\nIain Dunning and Joey Huchette and Miles Lubin. JuMP: A Modeling Language for Mathematical Optimization, SIAM Review, SIAM 59 (2017), pp. 295-320.","category":"page"},{"location":"cite/#Citing-EAGO","page":"Citing EAGO","title":"Citing EAGO","text":"","category":"section"},{"location":"cite/","page":"Citing EAGO","title":"Citing EAGO","text":"Please cite the following paper when using EAGO.jl:","category":"page"},{"location":"cite/","page":"Citing EAGO","title":"Citing EAGO","text":"Wilhelm, M.E. and Stuber, M.D. EAGO.jl: easy advanced global optimization in Julia.\nOptimization Methods and Software. 37(2): 425-450 (2022). DOI: 10.1080/10556788.2020.1786566","category":"page"},{"location":"dev/api_functions/#Functions","page":"Functions","title":"Functions","text":"","category":"section"},{"location":"dev/api_functions/","page":"Functions","title":"Functions","text":"Modules = [EAGO]\nOrder = [:function]","category":"page"},{"location":"dev/api_functions/#EAGO._add_constraint_store_ci!-Union{Tuple{S}, Tuple{F}, Tuple{Any, InputProblem, Type{F}, Type{S}}} where {F, S}-dev-api_functions","page":"Functions","title":"EAGO._add_constraint_store_ci!","text":"_add_constraint_store_ci!(\n d,\n m::InputProblem,\n _::Type{F},\n _::Type{S}\n)\n\n\nAdd a constraint to the local problem, storing the new constraint index and the associated index in the input problem.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._add_constraint_store_ci_linear!-Tuple{Any, InputProblem}-dev-api_functions","page":"Functions","title":"EAGO._add_constraint_store_ci_linear!","text":"_add_constraint_store_ci_linear!(d, ip::InputProblem)\n\n\nAdd linear constraints to the local problem, storing the new constraint indices and the associated indices in the input problem.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._add_constraint_store_ci_quadratic!-Tuple{Any, InputProblem}-dev-api_functions","page":"Functions","title":"EAGO._add_constraint_store_ci_quadratic!","text":"_add_constraint_store_ci_quadratic!(d, ip::InputProblem)\n\n\nAdd quadratic constraints to the local problem, storing the new constraint indices and the associated indices in the input problem.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._bvi-Tuple{GlobalOptimizer, Int64}-dev-api_functions","page":"Functions","title":"EAGO._bvi","text":"_bvi(m::GlobalOptimizer, i::Int64) -> Int64\n\n\nReturn the branch-to-sol mapping for the i'th variable.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._constraint_primal-Union{Tuple{S}, Tuple{F}, Tuple{GlobalOptimizer, Type{F}, Type{S}}} where {F, S}-dev-api_functions","page":"Functions","title":"EAGO._constraint_primal","text":"_constraint_primal\n\nHelper function which simplifies finding constraints of different types. See also: _constraints\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._constraints-Tuple{Optimizer, Type{MathOptInterface.VariableIndex}, Type{MathOptInterface.LessThan{Float64}}}-dev-api_functions","page":"Functions","title":"EAGO._constraints","text":"_constraints\n\nHelper function which simplifies finding constraints of different types. See also: _constraint_primal\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._diam-Tuple{EAGO.BranchVar, GlobalOptimizer, Int64}-dev-api_functions","page":"Functions","title":"EAGO._diam","text":"_diam(::BranchVar, ::GlobalOptimizer, ::Int)\n_diam(::FullVar, ::GlobalOptimizer, ::Int)\n\nReturn the diameter of a variable (upper bound - lower bound).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._ext-Union{Tuple{SubSolvers{Q, S, T}}, Tuple{T}, Tuple{S}, Tuple{Q}} where {Q<:MathOptInterface.AbstractOptimizer, S<:MathOptInterface.AbstractOptimizer, T<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO._ext","text":"_ext(::Optimizer)\n_ext(::GlobalOptimizer)\n_ext(::SubSolvers)\n\nReturn the extension (<: ExtensionType) from the SubSolvers (sub)field or object.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._extract_primal!-Union{Tuple{S}, Tuple{F}, Tuple{Any, InputProblem, Type{F}, Type{S}}} where {F, S}-dev-api_functions","page":"Functions","title":"EAGO._extract_primal!","text":"_extract_primal!(d, m::InputProblem, _::Type{F}, _::Type{S})\n\n\nExtract primal constraint value from the local problem and save the result to the appropriate field of the optimizer.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._extract_primal_linear!-Tuple{Any, InputProblem}-dev-api_functions","page":"Functions","title":"EAGO._extract_primal_linear!","text":"_extract_primal_linear!(d, ip::InputProblem)\n\n\nExtract linear primal constraint values from the local problem and save the result to the appropriate field of the optimizer.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._extract_primal_quadratic!-Tuple{Any, InputProblem}-dev-api_functions","page":"Functions","title":"EAGO._extract_primal_quadratic!","text":"_extract_primal_quadratic!(d, ip::InputProblem)\n\n\nExtract quadratic primal constraint values from the local problem and save the result to the appropriate field of the optimizer.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._is_branch_var-Tuple{GlobalOptimizer, Any}-dev-api_functions","page":"Functions","title":"EAGO._is_branch_var","text":"_is_branch_var(m::GlobalOptimizer, i) -> Any\n\n\nCheck if m._branch_variables[i] is true or false.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._is_input_min-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO._is_input_min","text":"_is_input_min(m::GlobalOptimizer) -> Bool\n\n\nCheck to see if the sense of the optimization problem is Min (true) or Max (false).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._relaxed_optimizer-Union{Tuple{SubSolvers{Q, S, T}}, Tuple{T}, Tuple{S}, Tuple{Q}} where {Q<:MathOptInterface.AbstractOptimizer, S<:MathOptInterface.AbstractOptimizer, T<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO._relaxed_optimizer","text":"_relaxed_optimizer(::GlobalOptimizer)\n_relaxed_optimizer(::SubSolvers)\n\nReturn the relaxed optimizer (<: MOI.AbstractOptimizer) from the SubSolvers field or object.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._svi-Tuple{GlobalOptimizer, Int64}-dev-api_functions","page":"Functions","title":"EAGO._svi","text":"_svi(m::GlobalOptimizer, i::Int64) -> Int64\n\n\nReturn the sol-to-branch mapping for the i'th variable.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._upper_optimizer-Union{Tuple{SubSolvers{Q, S, T}}, Tuple{T}, Tuple{S}, Tuple{Q}} where {Q<:MathOptInterface.AbstractOptimizer, S<:MathOptInterface.AbstractOptimizer, T<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO._upper_optimizer","text":"_upper_optimizer(::GlobalOptimizer)\n_upper_optimizer(::SubSolvers)\n\nReturn the upper optimizer (<: MOI.AbstractOptimizer) from the SubSolvers field or object.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.add_nonlinear!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.add_nonlinear!","text":"add_nonlinear!(m::GlobalOptimizer)\n\n\nAdd an Evaluator and nonlinear functions and populate each appropriately.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.add_nonlinear_evaluator!-Tuple{GlobalOptimizer, Nothing}-dev-api_functions","page":"Functions","title":"EAGO.add_nonlinear_evaluator!","text":"add_nonlinear_evaluator!\n\nAdd an Evaluator structure if nonlinear terms are attached.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.add_objective!-Tuple{ParsedProblem, Any}-dev-api_functions","page":"Functions","title":"EAGO.add_objective!","text":"add_objective!\n\nAdd objective function (if any) to the parsed problem.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.affine_relax_quadratic!-Tuple{GlobalOptimizer, MathOptInterface.ScalarQuadraticFunction{Float64}, Dict{Int64, Float64}, MathOptInterface.ScalarAffineFunction{Float64}}-dev-api_functions","page":"Functions","title":"EAGO.affine_relax_quadratic!","text":"affine_relax_quadratic!\n\nDefault routine for relaxing quadratic constraint func < 0.0 on node n. Takes affine bounds of convex part at point x0 and secant line bounds on concave parts.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.aggressive_filtering!-Union{Tuple{Q}, Tuple{S}, Tuple{R}, Tuple{GlobalOptimizer{R, S, Q}, NodeBB}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.aggressive_filtering!","text":"aggressive_filtering!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType},\n n::NodeBB\n) -> Bool\n\n\nExcludes OBBT on variable indices after a search in a filtering direction.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.bool_indx_diff!-Tuple{Vector{Bool}, Vector{Bool}, Vector{Bool}}-dev-api_functions","page":"Functions","title":"EAGO.bool_indx_diff!","text":"bool_indx_diff!(\n z::Vector{Bool},\n x::Vector{Bool},\n y::Vector{Bool}\n) -> Vector{Bool}\n\n\nUtility function used to set vector of booleans z to x & ~y. Avoids the generation of conversion of the BitArray created by broadcasting logical operators.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.bound_objective-Tuple{GlobalOptimizer, EAGO.BufferedNonlinearFunction}-dev-api_functions","page":"Functions","title":"EAGO.bound_objective","text":"bound_objective(::GlobalOptimizer, ::T)\nbound_objective(::ExtensionType, ::GlobalOptimizer)\n\nCompute a tuple representing the lower and upper bounds for an objective function. Note: bound_objective(::GlobalOptimizer) dispatches to bound_objective(::ExtensionType, ::GlobalOptimizer).\n\nOptions for T:\n\nAffineFunctionIneq\nBufferedNonlinearFunction\nBufferedQuadraticIneq\nMOI.VariableIndex\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.branch_node!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.branch_node!","text":"branch_node!(t::ExtensionType, m::GlobalOptimizer)\n\n\nCreate two nodes from current_node and store them on the stack. Call select_branch_variable(t, m) and select_branch_point(t, m, k) to determine the variable that should be branched on and the point at which branching should occur, respectively.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.build_model-Union{Tuple{S}, Tuple{A}, Tuple{EAGO.DefaultExt, A, S, SIPProblem}} where {A<:AbstractSIPAlgo, S<:AbstractSubproblemType}-dev-api_functions","page":"Functions","title":"EAGO.build_model","text":"build_model\n\nCreate the model and variables used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command build_model(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, p::SIPProblem).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.check_set_affine_nl!-Union{Tuple{Q}, Tuple{T}, Tuple{N}, Tuple{S}, Tuple{R}, Tuple{V}, Tuple{GlobalOptimizer{R, S, Q}, EAGO.BufferedNonlinearFunction{V, N, T}, Bool, Bool}} where {V, R, S, N, T<:RelaxTag, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.check_set_affine_nl!","text":"check_set_affine_nl!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType},\n f::EAGO.BufferedNonlinearFunction{V, N, T<:RelaxTag},\n finite_cut::Bool,\n check_safe::Bool\n) -> Bool\n\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.convergence_check-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.convergence_check","text":"convergence_check(\n t::ExtensionType,\n m::GlobalOptimizer\n) -> Bool\n\n\nCheck for problem convergence.\n\nBy default, check if the lower and upper bounds have converged to within absolute and/or relative tolerances.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.create_buffer_dict-Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}}-dev-api_functions","page":"Functions","title":"EAGO.create_buffer_dict","text":"create_buffer_dict(\n func::MathOptInterface.ScalarQuadraticFunction{Float64}\n) -> Dict{Int64, Float64}\n\n\nCreate a buffer dictionary from a ScalarQuadraticFunction.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.cut-Union{Tuple{T}, Tuple{N}, Tuple{MC{N, T}, MC{N, T}, EAGO.VariableValues, Float64, Vector{Int64}, Bool, Bool}} where {N, T<:RelaxTag}-dev-api_functions","page":"Functions","title":"EAGO.cut","text":"cut\n\nIntersects the new set valued operator with the prior and performs affine bound tightening\n\nFirst forward pass: post should be set by user option, is_intersect should be false so that the tape overwrites existing values, and the interval_intersect flag could be set to either value.\nForward CP pass (assumes same reference point): post should be set by user option, is_intersect should be true so that the tape intersects with existing values, and the interval_intersect flag should be false.\nForward CP pass (assumes same reference point): post should be set by user option, is_intersect should be true so that the tape intersects with existing values, and the interval_intersect flag should be false.\nSubsequent forward passes at new points: postshould be set by user option,isintersectshould be true so that the tape intersects with existing values, and theintervalintersectflag should betrue` as predetermined interval bounds are valid but the prior values may correspond to different points of evaluation.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.cut_condition-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.cut_condition","text":"cut_condition(t::ExtensionType, m::GlobalOptimizer) -> Bool\n\n\nReturns true if a cut should be added and computes a new reference point to add the cut at. By default, checks that cut_max_iterations are not exceeded and that the improvement in the objective value associated with the previous cut is greater than both an absolute tolerance cut_ϵ_abs and a relative tolerance cut_ϵ_rel. Returns false otherwise.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.default_upper_heuristic-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.default_upper_heuristic","text":"default_upper_heuristic(m::GlobalOptimizer) -> Bool\n\n\nDefault check to see if the upper bounding problem should be run. By default, The upper bounding problem is run on every node up to depth upper_bounding_depth and is triggered with a probability of 0.5^(depth - upper_bounding_depth) afterwards for continuous problems. For integral problems, the upper_bounding_depth approach is used as well as running on every node up to depth upper_bounding_depth + cont_depth with another trigger of probability 0.5^(depth - upper_bounding_depth - cont_depth).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.diam-Union{Tuple{VariableInfo{T}}, Tuple{T}} where T<:AbstractFloat-dev-api_functions","page":"Functions","title":"EAGO.diam","text":"Return the diameter of a variable (upper bound - lower bound).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.eliminate_fixed_variables!-dev-api_functions","page":"Functions","title":"EAGO.eliminate_fixed_variables!","text":"eliminate_fixed_variables!(::T, ::Vector{VariableInfo})\n\nEliminate fixed variables by rearrangment or restructuring of the AbstractEAGOConstraint.\n\nOptions for T (all are subtypes of AbstractEAGOConstraint):\n\nAffineFunctionEq\nAffineFunctionIneq\nBufferedQuadraticIneq\nBufferedNonlinearFunction{N,T} where {N, T<:RelaxTag}\nNonlinearExpression{V,N,T} where {V, N, T<:RelaxTag}\n\n\n\n\n\n","category":"function"},{"location":"dev/api_functions/#EAGO.f_init!-Tuple{AbstractCacheAttribute, AbstractDirectedGraph, AbstractCache}-dev-api_functions","page":"Functions","title":"EAGO.f_init!","text":"Initializes information in cache c for each node in g that may be used in a forward-pass of attribute t. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.fathom!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.fathom!","text":"fathom!(t::ExtensionType, m::GlobalOptimizer)\n\n\nRemove nodes from the stack. By default, delete nodes from the stack if their lower bounds are greater than the current global upper bound.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.fbbt!-dev-api_functions","page":"Functions","title":"EAGO.fbbt!","text":"fbbt!(m::GlobalOptimizer, f::T)\n\nPerforms feasibility-based bound tightening on a back-end constraint and returns true if it is feasible or false if it is infeasible.\n\nOptions for T (all are subtypes of AbstractEAGOConstraint):\n\nAffineFunctionIneq\nAffineFunctionEq\n\n\n\n\n\n","category":"function"},{"location":"dev/api_functions/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Constant, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a constant v at index k in cache c associated with graph g using information at index k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Expression, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a expression v at index k in cache c associated with graph g using information taken from the children of k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Parameter, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a parameter v at index k in cache c associated with graph g using information at index k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Subexpression, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a subexpression v at index k in cache c associated with graph g using information taken from the children of k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Variable, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a variable v at index k in cache c associated with graph g using information at index k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.get_sip_optimizer-Union{Tuple{A}, Tuple{ExtensionType, A, AbstractSubproblemType}} where A<:AbstractSIPAlgo-dev-api_functions","page":"Functions","title":"EAGO.get_sip_optimizer","text":"get_sip_optimizer\n\nSpecifices the optimizer to be used in extension t::EAGO.ExtensionType with algorithm alg::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command get_sip_optimizer(t::ExtensionType, alg::AbstractSIPAlgo, s::AbstractSubproblemType).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.global_solve!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.global_solve!","text":"global_solve!(m::GlobalOptimizer)\n\n\nSolves the branch-and-bound problem with the input EAGO.GlobalOptimizer object.\n\nPseudocode description of the algorithm, as implemented here:\n\n-I) Prepare optimizers and stack for branch-and-bound\n\n-II) While no reason to terminate the algorithm has occurred:\n\n–-II.A) Fathom nodes from the stack\n\n–-II.B) Select the new \"current node\" from the stack\n\n–-II.C) Perform preprocessing on current node\n\n–-II.D) If preprocessing result is feasible:\n\n––-II.D.1) Solve lower problem for current node\n\n––-II.D.2) If lower problem result is feasible and lower/upper bounds have not converged:\n\n–––-II.D.2.a) Solve upper problem for current node\n\n–––-II.D.2.b) Update the global upper bound if necessary\n\n–––-II.D.2.c) Perform postprocessing\n\n–––-II.D.2.d) If postprocessing result is feasible:\n\n––––-II.D.2.d.α) Branch and add the nodes back to the stack\n\n–-II.E) Update the global lower bound if necessary\n\n–-II.F) Update log information\n\n-III) Set termination and result statuses\n\n-IV) Print solution\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.initial_parse!-Union{Tuple{Optimizer{R, S, T}}, Tuple{T}, Tuple{S}, Tuple{R}} where {R, S, T}-dev-api_functions","page":"Functions","title":"EAGO.initial_parse!","text":"initial_parse!(m::Optimizer{R, S, T})\n\n\nTranslate the input problem to the working problem. Any checks or optional manipulation are left to the presolve stage.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.initialize!-Tuple{AbstractCache, AbstractDirectedGraph}-dev-api_functions","page":"Functions","title":"EAGO.initialize!","text":"initialize!(_::AbstractCache, _::AbstractDirectedGraph)\n\n\nFunction used to initialize the storage cache d::AbstractCache for a given type of directed acyclic graph g::AbstractDirectedGraph.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.initialize_stack!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.initialize_stack!","text":"initialize_stack!(t::ExtensionType, m::GlobalOptimizer)\n\n\nPrepare the stack for the branch-and-bound routine. By default, create an initial node with the variable bounds as box constraints and add it to the stack.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.interval_bound-dev-api_functions","page":"Functions","title":"EAGO.interval_bound","text":"interval_bound(::GlobalOptimizer, ::T)\n\nCompute a tuple representing the lower and upper interval bounds for an AbstractEAGOConstraint representing an equality constraint.\n\nOptions for T (all are subtypes of AbstractEAGOConstraint):\n\nAffineFunctionEq\nAffineFunctionIneq\nBufferedQuadraticEq\nBufferedQuadraticIneq\nBufferedNonlinearFunction{V,N,T} where {V,N,T}\n\n\n\n\n\n","category":"function"},{"location":"dev/api_functions/#EAGO.interval_objective_bound!-dev-api_functions","page":"Functions","title":"EAGO.interval_objective_bound!","text":"\n\n\n\n","category":"function"},{"location":"dev/api_functions/#EAGO.is_feasible-Tuple{GlobalOptimizer, Union{EAGO.AffineFunctionIneq, EAGO.BufferedQuadraticIneq}}-dev-api_functions","page":"Functions","title":"EAGO.is_feasible","text":"is_feasible(::GlobalOptimizer, ::T)\n\nCheck if a given bound is feasible.\n\nOptions for T (all are subtypes of AbstractEAGOConstraint):\n\nAffineFunctionIneq\nAffineFunctionEq\nBufferedQuadraticIneq\nBufferedQuadraticEq\nBufferedNonlinearFunction{V,N,T}\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.is_integer_feasible_local-Tuple{GlobalOptimizer, Any}-dev-api_functions","page":"Functions","title":"EAGO.is_integer_feasible_local","text":"is_integer_feasible_local(m::GlobalOptimizer, d) -> Bool\n\n\nChecks that the solution of a local solve is integer feasible to within the tolerances specified by integer_abs_tol and integer_rel_tol.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.is_integer_feasible_relaxed-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.is_integer_feasible_relaxed","text":"is_integer_feasible_relaxed(m::GlobalOptimizer) -> Bool\n\n\nCheck that the solution of the lower (relaxed problem) is integer feasible to within tolerances specified by the parameters: integer_abs_tol (absolute tolerance) and integer_rel_tol (relative tolerance).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.is_integer_subproblem-Tuple{Any}-dev-api_functions","page":"Functions","title":"EAGO.is_integer_subproblem","text":"is_integer_subproblem(m)\n\n\nReturns true that the subproblem at the current node n has participating integer variables that have not been fixed to constant valued as the branch-and-bound algorithm progresses. Returns false otherwise.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.is_safe_cut!-Tuple{GlobalOptimizer, MathOptInterface.ScalarAffineFunction{Float64}}-dev-api_functions","page":"Functions","title":"EAGO.is_safe_cut!","text":"is_safe_cut!(\n m::GlobalOptimizer,\n f::MathOptInterface.ScalarAffineFunction{Float64}\n) -> Bool\n\n\nApplies the safe cut checks detailed in Khajavirad, 2018 [Khajavirad, Aida, and Nikolaos V. Sahinidis. \"A hybrid LP/NLP paradigm for global optimization relaxations.\" Mathematical Programming Computation 10.3 (2018): 383-421] to ensure that only numerically safe affine relaxations are added. Checks that:\n\n|b| <= safe b, \nsafe_l <= abs(ai) <= safe u, and \nsafe_l <= abs(ai/aj) <= safe_u.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.label_branch_variables!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.label_branch_variables!","text":"label_branch_variables!(m::GlobalOptimizer)\n\n\nDetect any variables participating in nonconvex terms and populate the _branch_variables storage array.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.label_fixed_variables!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.label_fixed_variables!","text":"label_fixed_variables!(m::GlobalOptimizer) -> Vector{Bool}\n\n\nDetect any variables set to a fixed value by equality or inequality constraints and populate the _fixed_variable storage array.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.load_fbbt_buffer!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.load_fbbt_buffer!","text":"load_fbbt_buffer!(m::GlobalOptimizer)\n\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.load_relaxed_problem!-Union{Tuple{GlobalOptimizer{R, S, Q}}, Tuple{Q}, Tuple{S}, Tuple{R}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.load_relaxed_problem!","text":"load_relaxed_problem!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType}\n)\n\n\nLoad variables, linear constraints, and empty storage space for the first NLP and quadratic cut into the relaxed optimizer.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.local_problem_status-Tuple{MathOptInterface.TerminationStatusCode, MathOptInterface.ResultStatusCode}-dev-api_functions","page":"Functions","title":"EAGO.local_problem_status","text":"local_problem_status(t, r)\n\n\nTakes an MOI.TerminationStatusCode and a MOI.ResultStatusCode and returns true if this corresponds to a solution that is proven to be feasible. Returns false otherwise.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.log_iteration!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.log_iteration!","text":"log_iteration!(m::GlobalOptimizer)\n\n\nIf log_on is true, the global_lower_bound, global_upper_bound, run_time, and node_count are stored every log_interval. If log_subproblem_info then the lower bound, feasibility and run times of the subproblems are logged every log_interval.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.lower_interval_bound-dev-api_functions","page":"Functions","title":"EAGO.lower_interval_bound","text":"lower_interval_bound(::GlobalOptimizer, ::T)\n\nCompute the lower interval bound for an AbstractEAGOConstraint representing an inequality constraint.\n\nOptions for T (all are subtypes of AbstractEAGOConstraint):\n\nAffineFunctionIneq\nBufferedQuadraticIneq\nBufferedSOC\nBufferedNonlinearFunction{V,N,T} where {V,N,T}\n\n\n\n\n\n","category":"function"},{"location":"dev/api_functions/#EAGO.lower_problem!-Union{Tuple{Q}, Tuple{S}, Tuple{R}, Tuple{ExtensionType, GlobalOptimizer{R, S, Q}}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.lower_problem!","text":"lower_problem!(\n t::ExtensionType,\n m::GlobalOptimizer{R, S, Q<:ExtensionType}\n)\n\n\nConstructs a relaxation of the MINLP on node y and solves it using the default EAGO relaxation scheme. By default, EAGO applies Kelley's algorithm (from Kelley Jr., J.E.: The cutting-plane method for solving convex programs. J. Soc. Ind. Appl. Math. 8(4), 703 to 712 (1960)) while cut_condition(m) returns true then activates the integrality constraints of the relaxed problems and solves the resulting MILP relaxation. results are stored to the _lower_solution, _lower_termination_status, _lower_primal_status, _lower_dual_status, _lower_objective_value, and _lower_feasibility. Further, lower and upper variable duals are stored _lower_lvd and _lower_uvd, respectively, for use in duality based bound tightening. If relaxation-based bounds are weaker or cutting-planes are numerically poorly ill-posed, then interval bounds are used instead. If the problem is dual feasible but the primal status is ambiguous the dual objective value is used for the lower bound to avoid numerical issues.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.mc_type-Union{Tuple{EAGO.RelaxCache{V, N, T}}, Tuple{T}, Tuple{N}, Tuple{V}} where {V, N, T<:RelaxTag}-dev-api_functions","page":"Functions","title":"EAGO.mc_type","text":"mc_type(::RelaxCache{V, N, T} where {V, N, T<:RelaxTag}\nmc_type(::NonlinearExpression{V, N, T} where {V, N, T<:RelaxTag}\nmc_type(::BufferedNonlinearFunction{V, N, T} where {V, N, T<:RelaxTag}\n\nReturns a McCormick structure of type MC{N, T<:RelaxTag}.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.mid-Union{Tuple{VariableInfo{T}}, Tuple{T}} where T<:AbstractFloat-dev-api_functions","page":"Functions","title":"EAGO.mid","text":"Return the midpoint of a variable (0.5*(upper bound + lower bound)).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.node_selection!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.node_selection!","text":"node_selection!(t::ExtensionType, m::GlobalOptimizer)\n\n\nSelect the next node in the stack to evaluate. By default, perform best-first node selection (select the node with the lowest lower bound in the stack).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.obbt!-Union{Tuple{GlobalOptimizer{R, S, Q}}, Tuple{Q}, Tuple{S}, Tuple{R}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.obbt!","text":"obbt!(m::GlobalOptimizer{R, S, Q<:ExtensionType}) -> Bool\n\n\nPerforms OBBT with filtering and greedy ordering as detailed in: Gleixner, A.M., Berthold, T., Müller, B. et al. J Glob Optim (2017) 67: 731. https://doi.org/10.1007/s10898-016-0450-4\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.objective_cut!-Tuple{GlobalOptimizer, Bool}-dev-api_functions","page":"Functions","title":"EAGO.objective_cut!","text":"objective_cut!\n\nAdd linear objective cut constraint to the m._subsolvers.relaxed_optimizer.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.optimize_hook!-Tuple{ExtensionType, Optimizer}-dev-api_functions","page":"Functions","title":"EAGO.optimize_hook!","text":"optimize_hook!(t::ExtensionType, m::Optimizer)\n\nProvide a hook for extensions to EAGO. \n\nThe user-defined extension of optimize_hook! is used in EAGO's overloading of MOI.optimize! (see EAGO.jl/src/eago_optimizer/optimize/optimize.jl). Without the optimize_hook! specified, EAGO will run initial_parse!, parse_classify_problem!, and then optimize! using the parsed problem type. The user-specified optimize_hook! should thus take the new extension and Optimizer as inputs and will execute when the user writes optimize!(model).\n\nExample\n\nHere, optimize_hook! is used to bypass EAGO's problem parsing and treat every problem using its branch-and-bound routine. This is done in this example by telling EAGO to treat the problem as a mixed integer nonconvex problem, which normally dispatches to branch-and-bound.\n\nstruct MyNewExtension <: EAGO.ExtensionType end\nimport EAGO: optimize_hook!\nfunction EAGO.optimize_hook!(t::MyNewExtension, m::Optimizer)\n initial_parse!(m)\n optimize!(EAGO.MINCVX(), m)\nend\n\nThe same functionality could be accomplished by setting the EAGOParameter field force_global_solve to be true.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.parse_classify_problem!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.parse_classify_problem!","text":"parse_classify_problem!(m::GlobalOptimizer)\n\nInterprets the type/number of constraints and the type of objective function to infer a problem type. Current possible types include:\n\nLP: Linear program; sent to optimize_lp.jl\n'MILP: Mixed integer linear program; sent tooptimize_lp.jl`\nSOCP: Second-order cone program; sent to optimize_conic.jl\nMINCVX: Mixed-integer nonconvex; sent to optimize_nonconvex.jl\n\nIf the force_global_solve parameter is set to true, parse_classify_problem! will set the problem type to MINCVX to pass the problem to optimize_nonconvex.jl.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.parse_global!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.parse_global!","text":"Basic parsing for global solutions (no extensive manipulation). By default, does nothing.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.postprocess!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.postprocess!","text":"postprocess!(t::ExtensionType, m::GlobalOptimizer)\n\n\nDefault postprocess perfoms duality-based bound tightening (Tawarmalani, M., Sahinidis, N.V.: Global optimization of mixed-integer nonlinear programs: a theoretical and computational study. Math. Progr. 99, 563–591 (2004).) up to an iteration limit set by dbbt_depth.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.preprocess!-Union{Tuple{Q}, Tuple{S}, Tuple{R}, Tuple{ExtensionType, GlobalOptimizer{R, S, Q}}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.preprocess!","text":"preprocess!(\n t::ExtensionType,\n m::GlobalOptimizer{R, S, Q<:ExtensionType}\n)\n\n\nRuns contractor methods prior to solving lower bounding problem. By default linear and quadratic contractor methods followed by interval constraint propagation then optimization-based bound tightening for a specified number of iterations while the subproblem at current node n has not been proven infeasible.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.presolve_global!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.presolve_global!","text":"presolve_global!(t::ExtensionType, m::GlobalOptimizer)\n\n\nPerform any necessary work prior to running branch-and-bound. \n\nSet subsolver configs using values in EAGOParameters;\nLoad variables, linear constraints, and empty storage space into the relaxed optimizer;\nPrepare the stack for the start of branch-and-bound;\nFill fields of the GlobalOptimizer with zeros of the proper dimensions;\nPass necessary flags from the GlobalOptimizer to the working problem.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.print_iteration!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.print_iteration!","text":"print_iteration!\n\nPrint status information based on iteration count. The header print frequency is based on the header_iterations setting, and the data print frequency is based on the output_iterations setting.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.print_node!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.print_node!","text":"print_node!\n\nPrint information about the current node. Includes node ID, lower bound, upper bound, and interval box.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.print_preamble!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.print_preamble!","text":"print_preamble!\n\nPrint noteworthy information prior to running branch-and-bound. Currently prints a note about flipping max(f) to -min(-f) internally, if a maximization problem is inputted and verbosity>=3.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.print_results!-Tuple{GlobalOptimizer, Bool}-dev-api_functions","page":"Functions","title":"EAGO.print_results!","text":"print_results!(m::GlobalOptimizer, lower_flag::Bool)\n\n\nPrint the results of a single (lower or upper) bounding problem. lower_flag=true prints information for the lower problem, lower_flag=false prints information for the upper problem.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.print_solution!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.print_solution!","text":"print_solution!\n\nPrint solution information for the B&B problem. Display node with the best solution, solution value, solution, and time spent solving subproblems. This print occurs following termination of the B&B algorithm.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.r_init!-Tuple{AbstractCacheAttribute, AbstractDirectedGraph, AbstractCache}-dev-api_functions","page":"Functions","title":"EAGO.r_init!","text":"Initializes information in cache c for each node in g that may be used in a reverse-pass of attribute t. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.reform_epigraph_min!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.reform_epigraph_min!","text":"reform_epigraph_min!(m::GlobalOptimizer)\n\n\nPerform an epigraph reformulation assuming the working_problem is a minimization problem.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.register_eago_operators!-Tuple{Model}-dev-api_functions","page":"Functions","title":"EAGO.register_eago_operators!","text":"registereagooperators!\n\nRegisters all nonstandard nonlinear terms available in EAGO in a JuMP. Uses of these is generally preferable in EAGO as the relaxations EAGO will generate will usually be tighter (speeding up convergence time). Note that this will work can be used by other nonlinear solvers (Ipopt for instance).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rel_diam-Tuple{GlobalOptimizer, Int64}-dev-api_functions","page":"Functions","title":"EAGO.rel_diam","text":"rel_diam(m::GlobalOptimizer, i::Int64) -> Float64\n\n\nReturn the relative diameter of a variable. In the case of diam(X)=Inf, rel_diam returns 0.0 to prevent \"branching\" on this variable endlessly.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.relax!-Tuple{GlobalOptimizer, EAGO.BufferedQuadraticEq, Int64, Bool}-dev-api_functions","page":"Functions","title":"EAGO.relax!","text":"relax!(\n m::GlobalOptimizer,\n f::EAGO.BufferedQuadraticEq,\n i::Int64,\n check_safe::Bool\n) -> Bool\n\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.relax!-Tuple{GlobalOptimizer, EAGO.BufferedQuadraticIneq, Int64, Bool}-dev-api_functions","page":"Functions","title":"EAGO.relax!","text":"relax!(\n m::GlobalOptimizer,\n f::EAGO.BufferedQuadraticIneq,\n k::Int64,\n check_safe::Bool\n) -> Bool\n\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.relax!-Union{Tuple{Q}, Tuple{T}, Tuple{N}, Tuple{S}, Tuple{R}, Tuple{V}, Tuple{GlobalOptimizer{R, S, Q}, EAGO.BufferedNonlinearFunction{V, N, T}, Int64, Bool}} where {V, R, S, N, T<:RelaxTag, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.relax!","text":"relax!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType},\n f::EAGO.BufferedNonlinearFunction{V, N, T<:RelaxTag},\n k::Int64,\n check_safe::Bool\n) -> Tuple{Bool, Bool}\n\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.relax!-dev-api_functions","page":"Functions","title":"EAGO.relax!","text":"relax!\n\nRelax the constraint by adding an affine constraint to the model.\n\n\n\n\n\n","category":"function"},{"location":"dev/api_functions/#EAGO.relax_all_constraints!-Tuple{ExtensionType, GlobalOptimizer, Int64}-dev-api_functions","page":"Functions","title":"EAGO.relax_all_constraints!","text":"relax_all_constraints!(\n t::ExtensionType,\n m::GlobalOptimizer,\n k::Int64\n) -> Tuple{Bool, Bool}\n\n\nA routine that adds relaxations for all nonlinear constraints and quadratic constraints corresponding to the current node to the relaxed problem. This adds an objective cut (if specified by objective_cut_on) and then sets the _new_eval_constraint flag to false indicating that an initial evaluation of the constraints has occurred. If the objective_cut_on flag is true then the _new_eval_objective flag is also set to false indicating that the objective expression was evaluated.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.relaxed_problem_status-Tuple{MathOptInterface.TerminationStatusCode, MathOptInterface.ResultStatusCode, MathOptInterface.ResultStatusCode}-dev-api_functions","page":"Functions","title":"EAGO.relaxed_problem_status","text":"relaxed_problem_status(t, p, d)\n\n\nTake an MOI.TerminationStatusCode and two MOI.ResultStatusCodes (one each for the primal and dual status) and return a RelaxResultStatus. Returns RRS_OPTIMAL if the codes prove that the subproblem solution was solved to global optimality. Returns RRS_INFEASIBLE if the codes prove that the subproblem solution is infeasible. Returns RRS_DUAL_FEASIBLE if subproblem solution is not optimal and not proven infeasible, but the dual status is MOI.FEASIBLE_POINT. Returns RRS_INVALID otherwise.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.repeat_check-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.repeat_check","text":"repeat_check(t::ExtensionType, m::GlobalOptimizer) -> Bool\n\n\nCheck to see if current node should be reprocessed. Without any custom extension, return false by default.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Constant, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a constant v at index k in cache c associated with graph g using information at index k taken from the parents of k.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Expression, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a expressions v at index k in cache c associated with graph g using information at index k taken from the parents of k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Parameter, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a parameters v at index k in cache c associated with graph g using information at index k taken from the parents of k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Subexpression, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a subexpressions v at index k in cache c associated with graph g using information at index k taken from the parents of k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Variable, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a variable v at index k in cache c associated with graph g using information at index k taken from the parents of k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop!-Union{Tuple{T}, Tuple{EAGO.RelaxInterval, Val{EAGO.MULT}, EAGO.DirectedTree, EAGO.IntervalCache{T}, Int64}} where T<:Real-dev-api_functions","page":"Functions","title":"EAGO.rprop!","text":"rprop!\n\nUpdates storage tapes with reverse evalution of node representing n = *(x,y,z...) which updates x, y, z and so on.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop!-Union{Tuple{T}, Tuple{EAGO.RelaxInterval, Val{EAGO.PLUS}, EAGO.DirectedTree, EAGO.IntervalCache{T}, Int64}} where T<:Real-dev-api_functions","page":"Functions","title":"EAGO.rprop!","text":"rprop!\n\nUpdates storage tapes with reverse evalution of node representing n = +(x,y,z...) which updates x, y, z and so on.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop_2!-Union{Tuple{T}, Tuple{N}, Tuple{V}, Tuple{EAGO.Relax, Val{EAGO.MULT}, EAGO.DirectedTree, EAGO.RelaxCache{V, N, T}, Int64}} where {V, N, T<:RelaxTag}-dev-api_functions","page":"Functions","title":"EAGO.rprop_2!","text":"rprop_2!\n\nUpdates storage tapes with reverse evalution of node representing n = x * y which updates x and y.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop_2!-Union{Tuple{T}, Tuple{N}, Tuple{V}, Tuple{EAGO.Relax, Val{EAGO.PLUS}, EAGO.DirectedTree, EAGO.RelaxCache{V, N, T}, Any}} where {V, N, T<:RelaxTag}-dev-api_functions","page":"Functions","title":"EAGO.rprop_2!","text":"rprop_2!\n\nUpdates storage tapes with reverse evalution of node representing n = x + y which updates x and y.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop_n!-Union{Tuple{T}, Tuple{N}, Tuple{V}, Tuple{EAGO.Relax, Val{EAGO.MULT}, EAGO.DirectedTree, EAGO.RelaxCache{V, N, T}, Int64}} where {V, N, T<:RelaxTag}-dev-api_functions","page":"Functions","title":"EAGO.rprop_n!","text":"rprop_n!\n\nUpdates storage tapes with reverse evalution of node representing n = *(x,y,z...) which updates x, y, z and so on.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop_n!-Union{Tuple{T}, Tuple{N}, Tuple{V}, Tuple{EAGO.Relax, Val{EAGO.PLUS}, EAGO.DirectedTree, EAGO.RelaxCache{V, N, T}, Int64}} where {V, N, T<:RelaxTag}-dev-api_functions","page":"Functions","title":"EAGO.rprop_n!","text":"rprop_n!\n\nUpdates storage tapes with reverse evalution of node representing n = +(x,y,z...) which updates x, y, z and so on.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.same_box-Tuple{NodeBB, NodeBB, Float64}-dev-api_functions","page":"Functions","title":"EAGO.same_box","text":"same_box(x::NodeBB, y::NodeBB, r::Float64) -> Bool\n\n\nCheck that node x and y have equal domains within an absolute tolerance of r.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.select_branch_point-Tuple{ExtensionType, GlobalOptimizer, Any}-dev-api_functions","page":"Functions","title":"EAGO.select_branch_point","text":"select_branch_point(\n t::ExtensionType,\n m::GlobalOptimizer,\n i\n) -> Float64\n\n\nSelect a point xb within the domain of the ith branching variable. By default, this point is a convex combination of the solution to the relaxation and the midpoint of the node (branch_cvx_factor*xmid + (1-branch_cvx_factor)*xsol). If the solution lies within branch_offset of a bound, then the branch point is moved to a distance of branch_offset from that bound.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.select_branch_variable-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.select_branch_variable","text":"select_branch_variable(\n t::ExtensionType,\n m::GlobalOptimizer\n) -> Any\n\n\nChoose a variable to branch on. A maximum relative width branching rule is used by default.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_constraint_propagation_fbbt!-Union{Tuple{GlobalOptimizer{R, S, Q}}, Tuple{Q}, Tuple{S}, Tuple{R}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.set_constraint_propagation_fbbt!","text":"set_constraint_propagation_fbbt!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType}\n) -> Bool\n\n\nPerforms bound tightening based on forward/reverse interval and/or McCormick passes. This routine resets the current node with new interval bounds.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_default_config!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.set_default_config!","text":"set_default_config!\n\nConfigures subsolver tolerances based on tolerance parameters provided to EAGO (provided that a specialized subsolver configuration routine has been provided and m.user_solver_config = false).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_dual!-Union{Tuple{GlobalOptimizer{R, S, Q}}, Tuple{Q}, Tuple{S}, Tuple{R}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.set_dual!","text":"set_dual!(m)\n\n\nRetrieves the lower and upper duals for variable bounds from the relaxed_optimizer and sets the appropriate values in the _lower_lvd and _lower_uvd storage fields.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_first_relax_point!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.set_first_relax_point!","text":"set_first_relax_point!(m::GlobalOptimizer)\n\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_global_lower_bound!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.set_global_lower_bound!","text":"set_global_lower_bound!(m::GlobalOptimizer)\n\n\nIf the previous best-known global lower bound is lower than the lowest lower bound in the stack, set the global lower bound equal to the lowest lower bound in the stack.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_node!-Tuple{Evaluator, NodeBB}-dev-api_functions","page":"Functions","title":"EAGO.set_node!","text":"set_node!\n\nSets the current node in the Evaluator structure.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_reference_point!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.set_reference_point!","text":"set_reference_point!(m::GlobalOptimizer)\n\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_result_status!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.set_result_status!","text":"set_result_status!(m::GlobalOptimizer)\n\n\nConvert EAGO's ending status code into an MOI.ResultStatusCode.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_termination_status!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.set_termination_status!","text":"set_termination_status!(m::GlobalOptimizer)\n\n\nConvert EAGO's ending status code into an MOI.TerminationStatusCode.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.single_storage!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.single_storage!","text":"single_storage!(t::ExtensionType, m::GlobalOptimizer)\n\n\nStore the current node to the stack, without branching, after updating lower/upper bounds.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.sip_bnd!-Union{Tuple{S}, Tuple{A}, Tuple{ExtensionType, A, S, SIPSubResult, SIPResult, SIPProblem, SIPCallback}} where {A<:AbstractSIPAlgo, S<:AbstractSubproblemType}-dev-api_functions","page":"Functions","title":"EAGO.sip_bnd!","text":"sip_bnd!\n\nSolves the bounding problem for the ith-SIP used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_bnd!(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, ..., i, tol).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.sip_llp!-Union{Tuple{S}, Tuple{A}, Tuple{EAGO.DefaultExt, A, S, SIPResult, SIPSubResult, SIPProblem, SIPCallback, Int64}, Tuple{EAGO.DefaultExt, A, S, SIPResult, SIPSubResult, SIPProblem, SIPCallback, Int64, Float64}} where {A<:AbstractSIPAlgo, S<:AbstractSubproblemType}-dev-api_functions","page":"Functions","title":"EAGO.sip_llp!","text":"sip_llp!\n\nSolves the lower level problem for the ith-SIP used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_llp!(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, ..., i, tol).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.sip_res!-Union{Tuple{A}, Tuple{ExtensionType, A, SIPSubResult, SIPResult, SIPProblem, SIPCallback}} where A<:AbstractSIPAlgo-dev-api_functions","page":"Functions","title":"EAGO.sip_res!","text":"sip_res!\n\nSolves the restriction problem for extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_res!(t::ExtensionType, a::AbstractSIPAlgo, ...).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.sip_solve-Union{Tuple{T}, Tuple{T, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Function, Vector}} where T<:AbstractSIPAlgo-dev-api_functions","page":"Functions","title":"EAGO.sip_solve","text":"sip_solve\n\nSolve an SIP with decision variable bounds x_l to x_u, uncertain variable bounds p_l to p_u, an objective function of f, and gSIP seminfiniite constraint(s).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.solve_local_nlp!-Union{Tuple{GlobalOptimizer{R, S, Q}}, Tuple{Q}, Tuple{S}, Tuple{R}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.solve_local_nlp!","text":"Constructs and solves the problem locally on node y updated the upper solution informaton in the optimizer.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.store_candidate_solution!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.store_candidate_solution!","text":"store_candidate_solution!(m::GlobalOptimizer)\n\n\nIf the most recent upper problem returned a feasible result, and the upper objective value is less than the previous best-known global upper bound, set the most recent upper problem result to be the new global upper bound. Update the _feasible_solution_found, _solution_node, _global_upper_bound, and _continuous_solution fields of the GlobalOptimizer accordingly.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.stored_adjusted_upper_bound!-Tuple{GlobalOptimizer, Float64}-dev-api_functions","page":"Functions","title":"EAGO.stored_adjusted_upper_bound!","text":"stored_adjusted_upper_bound!(d, v)\n\n\nShifts the resulting local nlp objective value f* by (1.0 + relative_tolerance/100.0)*f* + absolute_tolerance/100.0. This assumes that the local solvers relative tolerance and absolute tolerance is significantly lower than the global tolerance (local problem is minimum).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.termination_check-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.termination_check","text":"termination_check(m::GlobalOptimizer)\ntermination_check(t::ExtensionType, m::GlobalOptimizer) -> Bool\n\nCheck for termination of the branch-and-bound algorithm.\n\nIf only the GlobalOptimizer is given as an argument, termination_check dispatches to the other form using the ExtensionType given in the SubSolvers. If there is no user-defined extension, then by default, this will check for satisfaction of absolute or relative tolerances, solution infeasibility, and other specified limits. Returns true if any conditions are met and branch-and-bound should end, and false otherwise.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.trivial_filtering!-Union{Tuple{Q}, Tuple{S}, Tuple{R}, Tuple{GlobalOptimizer{R, S, Q}, NodeBB}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.trivial_filtering!","text":"trivial_filtering!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType},\n n::NodeBB\n)\n\n\nExcludes OBBT on variable indices that are tight for the solution of the relaxation.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.unbounded_check!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.unbounded_check!","text":"unbounded_check!(m::GlobalOptimizer) -> Union{Nothing, Bool}\n\n\nCheck the optimization problem for unbounded branching variables, which would interfere with EAGO's branch-and-bound routine since there are no well-defined branching rules for cases where the interval bounds contain -Inf or Inf. If any branching variables are missing bounds, add the missing bound at +/- 1E10 and warn the user.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.unpack_fbbt_buffer!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.unpack_fbbt_buffer!","text":"unpack_fbbt_buffer!(m::GlobalOptimizer)\n\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.unpack_global_solution!-Union{Tuple{Optimizer{R, S, Q}}, Tuple{Q}, Tuple{S}, Tuple{R}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.unpack_global_solution!","text":"unpack_global_solution!(\n m::Optimizer{R, S, Q<:ExtensionType}\n)\n\n\nIf global optimization was performed, much of the work happened within the _global_optimizer::GlobalOptimizer. The unpack_global_solution! function extracts results from the GlobalOptimizer and puts them in the correct fields of the Optimizer.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.unsafe_check_fill!-Union{Tuple{T}, Tuple{Any, Vector{T}, T, Int64}} where T-dev-api_functions","page":"Functions","title":"EAGO.unsafe_check_fill!","text":"unsafe_check_fill!(f, y::Array{T, 1}, x, n::Int64)\n\n\nPerforms map!(f, y, x) in an unsafe manner if y[i] is true, else no-op. Assumes n == length(x) == length(y). About 2x faster for small arrays (n < 1000).\n\n[Unused]\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.update_relaxed_problem_box!-Union{Tuple{GlobalOptimizer{R, S, Q}}, Tuple{Q}, Tuple{S}, Tuple{R}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.update_relaxed_problem_box!","text":"update_relaxed_problem_box!(m)\n\n\nUpdate the relaxed constraint by setting the constraint set of v == x* , xL_i <= x_i, and x_i <= xU_i for each such constraint added to the relaxed optimizer. Resets integral valued constraints to either EqualTo or Interval constraints.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.upper_problem!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.upper_problem!","text":"upper_problem!(t::ExtensionType, m::GlobalOptimizer)\n\n\nDefault upper bounding problem which simply calls solve_local_nlp! to solve the NLP locally.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.variable_dbbt!-Tuple{NodeBB, Vector{Float64}, Vector{Float64}, Float64, Float64, Int64}-dev-api_functions","page":"Functions","title":"EAGO.variable_dbbt!","text":"variable_dbbt!(\n n::NodeBB,\n mult_lo::Vector{Float64},\n mult_hi::Vector{Float64},\n LBD::Float64,\n UBD::Float64,\n nx::Int64\n)\n\n\nTighten the bounds of the _current_node using the current global upper bound and the duality information obtained from the relaxation.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.variable_load_parse!-Union{Tuple{T}, Tuple{Optimizer, Type{MathOptInterface.VariableIndex}, Type{T}}} where T-dev-api_functions","page":"Functions","title":"EAGO.variable_load_parse!","text":"variable_load_parse!\n\nParse constraint information of a given constraint type to fill in related variable information.\n\n\n\n\n\n","category":"method"},{"location":"ref/#References","page":"References","title":"References","text":"","category":"section"},{"location":"ref/#Branch-and-Bound","page":"References","title":"Branch and Bound","text":"","category":"section"},{"location":"ref/","page":"References","title":"References","text":"Floudas, CA (2013). Deterministic global optimization: theory, methods and applications. Vol. 37. Springer Science & Business Media.\nHorst, R, Tuy, H (2013). Global optimization: Deterministic approaches. Springer Science & Business Media.","category":"page"},{"location":"ref/#Parametric-Interval-Techniques","page":"References","title":"Parametric Interval Techniques","text":"","category":"section"},{"location":"ref/","page":"References","title":"References","text":"Hansen ER, Walster GW (2004). Global Optimization Using Interval Analysis. Marcel Dekker, New York, second edition.\nKrawczyk R (1969). Newton-algorithmen zur bestimmung con nullstellen mit fehler-schranken. Computing, 4:187–201.\nKrawczyk R (1984). Interval iterations for including a set of solutions. Computing, 32:13–31.\nMiranda C (1940). Un’osservatione su un teorema di brower. Boll. Un. Mat. Ital., 3:5–7.\nNeumaier A (1990). Interval Methods for Systems of Equations. Cambridge University Press, Cambridge.\nMoore RE (1977). A test for existence of solutions to nonlinear systems. SIAM Journal on Numerical Analysis, 14(4):611–615.","category":"page"},{"location":"ref/#Domain-Reduction","page":"References","title":"Domain Reduction","text":"","category":"section"},{"location":"ref/","page":"References","title":"References","text":"Benhamou F, & Older WJ (1997). Applying interval arithmetic to real, integer, and boolean constraints. The Journal of Logic Programming, 32, 1–24.\nCaprara A, & Locatelli M (2010). Global optimization problems and domain reduction strategies. Mathematical Programming, 125, 123–137.\nGleixner AM, Berthold T, Müller B, & Weltge S (2016). Three enhancements for optimization-based bound tightening. ZIB Report, 15–16.\nRyoo HS, & Sahinidis NV (1996). A branch-and-reduce approach to global optimization. Journal of Global Optimization, 8, 107–139.\nSchichl H, & Neumaier A (2005). Interval analysis on directed acyclic graphs for global optimization. Journal of Global Optimization, 33, 541–562.\nTawarmalani, M, & Sahinidis, NV (2005). A polyhedral branch-and-cut approach to global optimization. Mathematical Programming, 103, 225–249.\nVu, X, Schichl, H, & Sam-Haroud, D (2009). Interval propagation and search on directed acyclic graphs for numerical constraint solving. Journal of Global Optimization, 45, 499–531.","category":"page"},{"location":"ref/#Generalized-McCormick-Relaxations","page":"References","title":"Generalized McCormick Relaxations","text":"","category":"section"},{"location":"ref/","page":"References","title":"References","text":"Chachuat, B (2014). MC++: a toolkit for bounding factorable functions, v1.0. Retrieved 2 July 2014 https://projects.coin-or.org/MCpp\nMitsos A, Chachuat B, and Barton PI. (2009). McCormick-based relaxations of algorithms. SIAM Journal on Optimization, 20(2):573–601.\nMcCormick, GP (1976).. Computability of global solutions to factorable nonconvex programs: Part I-Convex underestimating problems. Mathematical Programming, 10:147–175.\nMcCormick, GP (1983). Nonlinear programming: Theory, Algorithms, and Applications. Wiley, New York.\nScott JK, Stuber MD, and Barton PI. (2011). Generalized McCormick relaxations. Journal of Global Optimization, 51(4):569–606.\nStuber MD, Scott JK, Barton PI (2015). Convex and concave relaxations of implicit functions. Optim. Methods Softw. 30(3), 424–460\nTsoukalas A and Mitsos A (2014). Multivariate McCormick Relaxations. Journal of Global Optimization, 59:633–662.\nKhan KA, Watson HAJ, Barton PI (2017). Differentiable McCormick relaxations. Journal of Global Optimization, 67(4):687-729.\nWechsung A, Scott JK, Watson HAJ, and Barton PI. (2015). Reverse propagation of McCormick relaxations. Journal of Global Optimization 63(1):1-36.","category":"page"},{"location":"ref/#Semi-Infinite-Programming","page":"References","title":"Semi-Infinite Programming","text":"","category":"section"},{"location":"ref/","page":"References","title":"References","text":"Mitsos A (2009). Global optimization of semi-infinite programs via restriction of the right-hand side. Optimization, 60(10-11):1291-1308.\nStuber MD and Barton PI (2015). Semi-Infinite Optimization With Implicit Functions. Industrial & Engineering Chemistry Research, 54:307-317, 2015.","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"(Image: logo)","category":"page"},{"location":"#EAGO-Easy-Advanced-Global-Optimization-in-Julia","page":"Introduction","title":"EAGO - Easy Advanced Global Optimization in Julia","text":"","category":"section"},{"location":"","page":"Introduction","title":"Introduction","text":"A development environment for robust and global optimization in Julia.","category":"page"},{"location":"#Authors","page":"Introduction","title":"Authors","text":"","category":"section"},{"location":"","page":"Introduction","title":"Introduction","text":"Matthew Wilhelm, Department of Chemical and Biomolecular Engineering, University of Connecticut (UConn)\nCurrent Position: Alexion Pharmaceuticals\nRobert Gottlieb, Department of Chemical and Biomolecular Engineering, University of Connecticut (UConn)\nDimitri Alston, Department of Chemical and Biomolecular Engineering, University of Connecticut (UConn)\nMatthew Stuber, Associate Professor, University of Connecticut (UConn)","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"If you would like to contribute, contact us.","category":"page"},{"location":"#Overview","page":"Introduction","title":"Overview","text":"","category":"section"},{"location":"","page":"Introduction","title":"Introduction","text":"EAGO is a global and robust optimization platform based on McCormick relaxations. It contains the first widely accessible global optimization routine based on generalized McCormick relaxations. With the exception of calls to local solvers and linear algebra routines, EAGO is written entirely in native Julia. The solver is flexibly arranged so the end user can easily customize low-level routines.","category":"page"},{"location":"#Installing-EAGO","page":"Introduction","title":"Installing EAGO","text":"","category":"section"},{"location":"","page":"Introduction","title":"Introduction","text":"EAGO is a registered Julia package and it can be installed using the Julia package manager. From the Julia REPL, type ] to enter the Package manager (Pkg) mode and run the following command:","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"pkg> add EAGO","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"Currently, EAGO is compatible with version 1.12 of JuMP. This allows a replication of some of the internal features shared by EAGO and JuMP's automatic differentiation scheme, e.g., generation of Wengert Tapes, passing evaluators between JuMP and EAGO, etc.","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"pkg> add JuMP","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"EAGO v0.8.1 is the current tagged version and requires Julia 1.6+ for full functionality (however Julia 1.0+ versions support partial functionality). Use with version 1.8 is recommended as the majority of in-house testing has occurred using this version of Julia. The user is directed to the High-Performance Configuration for instructions on how to install a high performance version of EAGO (rather than the basic entirely open-source version). If any issues are encountered when loading EAGO (or when using it), please submit an issue using the GitHub issue tracker.","category":"page"},{"location":"#Examples","page":"Introduction","title":"Examples","text":"","category":"section"},{"location":"","page":"Introduction","title":"Introduction","text":"Several examples are provided within this documentation, but additional examples are provided in the form of Jupyter Notebooks at EAGO-notebooks which can be run using IJulia. To add IJulia, run the command:","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"pkg> add IJulia","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"Then launch the Jupyter Notebook using the following command from the Julia terminal:","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"julia> using IJulia; notebook()","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"And then simply navigate to the example directory and run the example of most interest.","category":"page"},{"location":"optimizer/domain_reduction/#Domain-Reduction","page":"Domain Reduction","title":"Domain Reduction","text":"","category":"section"},{"location":"optimizer/domain_reduction/#Duality-Based-Bound-Tightening","page":"Domain Reduction","title":"Duality-Based Bound Tightening","text":"","category":"section"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"Variable bound tightening based on the duality multipliers are supported.","category":"page"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"variable_dbbt!","category":"page"},{"location":"optimizer/domain_reduction/#EAGO.variable_dbbt!","page":"Domain Reduction","title":"EAGO.variable_dbbt!","text":"variable_dbbt!(\n n::NodeBB,\n mult_lo::Vector{Float64},\n mult_hi::Vector{Float64},\n LBD::Float64,\n UBD::Float64,\n nx::Int64\n)\n\n\nTighten the bounds of the _current_node using the current global upper bound and the duality information obtained from the relaxation.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/domain_reduction/#Special-Forms","page":"Domain Reduction","title":"Special Forms","text":"","category":"section"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"Bound tightening for linear forms, univariate quadratic forms, and bivariate quadratic forms are also supported.","category":"page"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"EAGO.fbbt!","category":"page"},{"location":"optimizer/domain_reduction/#EAGO.fbbt!","page":"Domain Reduction","title":"EAGO.fbbt!","text":"fbbt!(m::GlobalOptimizer, f::T)\n\nPerforms feasibility-based bound tightening on a back-end constraint and returns true if it is feasible or false if it is infeasible.\n\nOptions for T (all are subtypes of AbstractEAGOConstraint):\n\nAffineFunctionIneq\nAffineFunctionEq\n\n\n\n\n\n","category":"function"},{"location":"optimizer/domain_reduction/#Constraint-Propagation","page":"Domain Reduction","title":"Constraint Propagation","text":"","category":"section"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"EAGO contains a constraint propagation architecture that supported forward and reverse evaluation of set-valued functions on the directed acyclic graph. The interval contractor and reverse McCormick relaxation-based contractors are currently available.","category":"page"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"EAGO.set_constraint_propagation_fbbt!","category":"page"},{"location":"optimizer/domain_reduction/#EAGO.set_constraint_propagation_fbbt!","page":"Domain Reduction","title":"EAGO.set_constraint_propagation_fbbt!","text":"set_constraint_propagation_fbbt!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType}\n) -> Bool\n\n\nPerforms bound tightening based on forward/reverse interval and/or McCormick passes. This routine resets the current node with new interval bounds.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/domain_reduction/#Optimization-Based-Bound-Tightening","page":"Domain Reduction","title":"Optimization-Based Bound Tightening","text":"","category":"section"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"EAGO makes use of an optimization-based bound tightening scheme using filtering and greedy ordering as detailed in [1].","category":"page"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"EAGO.obbt!\nEAGO.trivial_filtering!(m::GlobalOptimizer{R,S,Q}, n::NodeBB) where {R,S,Q<:ExtensionType}\nEAGO.aggressive_filtering!(m::GlobalOptimizer{R,S,Q}, n::NodeBB) where {R,S,Q<:ExtensionType}\nEAGO.bool_indx_diff!(z::Vector{Bool},x::Vector{Bool}, y::Vector{Bool})","category":"page"},{"location":"optimizer/domain_reduction/#EAGO.obbt!","page":"Domain Reduction","title":"EAGO.obbt!","text":"obbt!(m::GlobalOptimizer{R, S, Q<:ExtensionType}) -> Bool\n\n\nPerforms OBBT with filtering and greedy ordering as detailed in: Gleixner, A.M., Berthold, T., Müller, B. et al. J Glob Optim (2017) 67: 731. https://doi.org/10.1007/s10898-016-0450-4\n\n\n\n\n\n","category":"function"},{"location":"optimizer/domain_reduction/#EAGO.trivial_filtering!-Union{Tuple{Q}, Tuple{S}, Tuple{R}, Tuple{GlobalOptimizer{R, S, Q}, NodeBB}} where {R, S, Q<:ExtensionType}","page":"Domain Reduction","title":"EAGO.trivial_filtering!","text":"trivial_filtering!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType},\n n::NodeBB\n)\n\n\nExcludes OBBT on variable indices that are tight for the solution of the relaxation.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/domain_reduction/#EAGO.aggressive_filtering!-Union{Tuple{Q}, Tuple{S}, Tuple{R}, Tuple{GlobalOptimizer{R, S, Q}, NodeBB}} where {R, S, Q<:ExtensionType}","page":"Domain Reduction","title":"EAGO.aggressive_filtering!","text":"aggressive_filtering!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType},\n n::NodeBB\n) -> Bool\n\n\nExcludes OBBT on variable indices after a search in a filtering direction.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/domain_reduction/#EAGO.bool_indx_diff!-Tuple{Vector{Bool}, Vector{Bool}, Vector{Bool}}","page":"Domain Reduction","title":"EAGO.bool_indx_diff!","text":"bool_indx_diff!(\n z::Vector{Bool},\n x::Vector{Bool},\n y::Vector{Bool}\n) -> Vector{Bool}\n\n\nUtility function used to set vector of booleans z to x & ~y. Avoids the generation of conversion of the BitArray created by broadcasting logical operators.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/domain_reduction/#References","page":"Domain Reduction","title":"References","text":"","category":"section"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"Gleixner, A.M., Berthold, T., Müller, B. et al. J Glob Optim (2017) 67: 731. https://doi.org/10.1007/s10898-016-0450-4","category":"page"}] +[{"location":"mccormick/usage/#Basic-Usage","page":"Basic Usage","title":"Basic Usage","text":"","category":"section"},{"location":"mccormick/usage/#Bounding-a-Univariate-Function","page":"Basic Usage","title":"Bounding a Univariate Function","text":"","category":"section"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"In order to bound a function using a McCormick relaxation, you first construct a McCormick object (x::MC) that bounds the input variables, and then you pass these variables to the desired function.","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"In the example below, convex/concave relaxations of the function f(x) = x (x - 5) sin(x) are calculated at x = 2 on the interval 1 4.","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"using McCormick\n\n# Create MC object for x = 2.0 on [1.0, 4.0] for relaxing\n# a function f(x) on the interval Intv\n\nf(x) = x*(x - 5.0)*sin(x)\n\nx = 2.0 # Value of independent variable x\nIntv = Interval(1.0, 4.0) # Define interval to relax over\n # Note that McCormick.jl reexports IntervalArithmetic.jl\n # and StaticArrays. So no using statement for these is\n # necessary.\n# Create McCormick object\nxMC = MC{1,NS}(x, Intv, 1)\n\nfMC = f(xMC) # Relax the function\n\ncv = fMC.cv # Convex relaxation\ncc = fMC.cc # Concave relaxation\ncvgrad = fMC.cv_grad # Subgradient/gradient of convex relaxation\nccgrad = fMC.cc_grad # Subgradient/gradient of concave relaxation\nIv = fMC.Intv # Retrieve interval bounds of f(x) on Intv","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"By plotting the results we can easily visualize the convex and concave relaxations, interval bounds, and affine bounds constructed using the subgradient at the middle of X.","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"(Image: Figure_1)","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"If we instead use the constructor xMC = MC{1,Diff}(x, Intv, 1) in the above code and re-plot, we arrive at the following graph. Note that these relaxations are differentiable, but not as tight as the nonsmooth relaxations.","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"(Image: Figure_2)","category":"page"},{"location":"mccormick/usage/#Bounding-a-Multivariate-Function","page":"Basic Usage","title":"Bounding a Multivariate Function","text":"","category":"section"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"This can readily be extended to multivariate functions, for example:","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"beginaligned\nf(xy) = big(4 - 21 x^2 + fracx^46 big) x^2 + x y + (-4 + 4 y^2) y^2\nendaligned","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"using McCormick\n\n# Define function\nf(x, y) = (4.0 - 2.1*x^2 + (x^4)/6.0)*x^2 + x*y + (-4.0 + 4.0*y^2)*y^2\n\n# Define intervals for independent variables\nn = 30\nX = Interval{Float64}(-2,0)\nY = Interval{Float64}(-0.5, 0.5)\nxrange = range(X.lo, stop=X.hi, length=n)\nyrange = range(Y.lo, stop=Y.hi, length=n)\n\n# Calculate differentiable McCormick relaxation\nfor (i,x) in enumerate(xrange)\n for (j,y) in enumerate(yrange)\n z = f(x, y) # Calculate function values\n xMC = MC{1,Diff}(x, X, 1) # Differentiable relaxation for x\n yMC = MC{1,Diff}(y, Y, 2) # Differentiable relaxation for y\n fMC = f(xMC, yMC) # Relax the function\n cv = fMC.cv # Convex relaxation\n cc = fMC.cc # Concave relaxation\n end\nend","category":"page"},{"location":"mccormick/usage/","page":"Basic Usage","title":"Basic Usage","text":"(Image: Figure_3)","category":"page"},{"location":"mccormick/operators/#Currently-Supported-Operators","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"","category":"section"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"The operators currently supported are listed below. The operators with a check box have been subject to a large degree of scrutiny and have been implemented for both forward and reverse McCormick relaxations (Wechsung2015). Each McCormick object is associated with a parameter T <: RelaxTag which is either NS for nonsmooth relaxations (Mitsos2009, Scott2011), MV for multivariate relaxations (Tsoukalas2014, Najman2017), or Diff for differentiable relaxations (Khan2016, Khan2018, Khan2019). Conversion between NS, MV, and Diff relax tags is not currently supported. Convex and concave envelopes are used to compute relaxations of univariate functions.","category":"page"},{"location":"mccormick/operators/#Univariate-McCormick-Operators","page":"Currently Supported Operators","title":"Univariate McCormick Operators","text":"","category":"section"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"Arbitrarily differentiable relaxations can be constructed for the following operators:","category":"page"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"Inverse (inv)\nLogarithms (log, log2, log10)\nExponential Functions (exp, exp2, exp10)\nSquare Root (sqrt)\nAbsolute Value (abs)","category":"page"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"Both nonsmooth and Whitney-1 (once differentiable) relaxations are supported for the following operators:","category":"page"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"Step Functions (step, sign)\nTrigonometric Functions (sin, cos, tan)\nInverse Trigonometric Functions (asin, acos, atan)\nHyperbolic Functions (sinh, cosh, tanh)\nInverse Hyperbolic Functions (asinh, acosh, atanh)\nCommon Activation Functions (relu, leaky_relu, param_relu, sigmoid, bisigmoid, softsign, softplus, maxtanh, pentanh, gelu, elu, selu, swish)\nSpecial Functions (erf)","category":"page"},{"location":"mccormick/operators/#Bivariate-McCormick-Operators","page":"Currently Supported Operators","title":"Bivariate McCormick Operators","text":"","category":"section"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"The following bivariate operators are supported for two MC objects. Both nonsmooth and Whitney-1 (once differentiable) relaxations are supported.","category":"page"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"Multiplication (*)\nDivision (/)","category":"page"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"Arbitrarily differentiable relaxations can be constructed for the following operators:","category":"page"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"Addition (+)\nSubtraction (-)\nMinimization (min)\nMaximization (max)","category":"page"},{"location":"mccormick/operators/#Common-Subexpressions","page":"Currently Supported Operators","title":"Common Subexpressions","text":"","category":"section"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"The following functions can be used in place of common subexpressions encountered in optimization and will result in improved performance (in each case, the standard McCormick composition rules are often more expansive).","category":"page"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"xexpax\narh\nxlogx\nmm","category":"page"},{"location":"mccormick/operators/#McCormick.xexpax","page":"Currently Supported Operators","title":"McCormick.xexpax","text":"expax\n\nThe expax function is defined as expax(x, a) = x*exp(a*x).\n\nForm defined in Najman, Jaromił, Dominik Bongartz, and Alexander Mitsos. \"Relaxations of thermodynamic property and costing models in process engineering.\" Computers & Chemical Engineering 130 (2019): 106571.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.arh","page":"Currently Supported Operators","title":"McCormick.arh","text":"arh\n\nThe arrhenius function arh is defined as arh(x) = exp(-k/x).\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.xlogx","page":"Currently Supported Operators","title":"McCormick.xlogx","text":"xlogx\n\nThe function xlogx is defined as xlogx(x) = x*log(x).\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.mm","page":"Currently Supported Operators","title":"McCormick.mm","text":"mm(X,v,K) = v*X / (X + K)\n\nA Michaelis-Menten rate function.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#Bound-Setting-Functions","page":"Currently Supported Operators","title":"Bound Setting Functions","text":"","category":"section"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"The following functions are used to specify that known bounds on a subexpression exist and that the relaxation/interval bounds propagated should make use of this information. The utility functions can be helpful in avoiding domain violations that arise due to the overly expansive nature of composite relaxations. Improper use of these functions may lead to cases in which the resulting relaxations are empty, so the user is encouraged to use discretion.","category":"page"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"positive\nnegative\nlower_bnd\nupper_bnd\nbnd","category":"page"},{"location":"mccormick/operators/#McCormick.positive","page":"Currently Supported Operators","title":"McCormick.positive","text":"positive(x::MC)\n\nSets the lower interval bound and the convex relaxation of x to a value of at least McCormick.MC_DOMAIN_TOL. (Sub)gradients are adjusted appropriately.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.negative","page":"Currently Supported Operators","title":"McCormick.negative","text":"negative(x::MC)\n\nSets the upper interval bound and the concave relaxation of x to a value of at most -McCormick.MC_DOMAIN_TOL. (Sub)gradients are adjusted appropriately.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.lower_bnd","page":"Currently Supported Operators","title":"McCormick.lower_bnd","text":"lower_bnd(x::MC, lb::Float64)\n\nSets the lower interval bound and the convex relaxation of x to a value of at least lb. (Sub)gradients are adjusted appropriately.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.upper_bnd","page":"Currently Supported Operators","title":"McCormick.upper_bnd","text":"upper_bnd(x::MC, ub)\n\nSets the upper interval bound and the concave relaxation of x to a value of at most ub. (Sub)gradients are adjusted appropriately.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.bnd","page":"Currently Supported Operators","title":"McCormick.bnd","text":"bnd(x::MC, lb, ub)\n\nSets the lower interval bound and the convex relaxation of x to a value of at least lb. Sets the upper interval bound and the concave relaxation of x to a value of at most ub. (Sub)gradients are adjusted appropriately.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#Specialized-Activation-Functions","page":"Currently Supported Operators","title":"Specialized Activation Functions","text":"","category":"section"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":" pentanh\n leaky_relu\n param_relu\n maxtanh","category":"page"},{"location":"mccormick/operators/#McCormick.pentanh","page":"Currently Supported Operators","title":"McCormick.pentanh","text":"pentanh\n\nThe pentanh activation function pentanh(x) = x > 0.0 ? tanh(x) : tanh(0.25*x).\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.leaky_relu","page":"Currently Supported Operators","title":"McCormick.leaky_relu","text":"leaky_relu\n\nThe leaky Rectified Linear Unit activation function leaky_relu(x) = max(x, 0.01x).\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.param_relu","page":"Currently Supported Operators","title":"McCormick.param_relu","text":"param_relu\n\nThe parametric Rectified Linear Unit activation function param_relu(x, α) = (max(x, αx) with α in [0,1].\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#McCormick.maxtanh","page":"Currently Supported Operators","title":"McCormick.maxtanh","text":"maxtanh\n\nThe maxtanh activation function maxtanh(x) = max(x, tanh(x)).\n\n\n\n\n\n","category":"function"},{"location":"mccormick/operators/#References","page":"Currently Supported Operators","title":"References","text":"","category":"section"},{"location":"mccormick/operators/","page":"Currently Supported Operators","title":"Currently Supported Operators","text":"Khan KA, Watson HAJ, Barton PI (2017). Differentiable McCormick relaxations. Journal of Global Optimization, 67(4): 687-729.\nKhan KA, Wilhelm ME, Stuber MD, Cao H, Watson HAJ, Barton PI (2018). Corrections to: Differentiable McCormick relaxations. Journal of Global Optimization, 70(3): 705-706.\nKhan KA (2019). Whitney differentiability of optimal-value functions for bound-constrained convex programming problems. Optimization, 68(2-3): 691-711\nMitsos A, Chachuat B, and Barton PI. (2009). McCormick-based relaxations of algorithms. SIAM Journal on Optimization, 20(2): 573–601.\nNajman J, Bongratz D, Tsoukalas A, and Mitsos A (2017). Erratum to: Multivariate McCormick relaxations. Journal of Global Optimization, 68: 219-225.\nScott JK, Stuber MD, and Barton PI. (2011). Generalized McCormick relaxations. Journal of Global Optimization, 51(4): 569–606.\nStuber MD, Scott JK, Barton PI (2015). Convex and concave relaxations of implicit functions. Optim. Methods Softw., 30(3): 424–460\nTsoukalas A and Mitsos A (2014). Multivariate McCormick Relaxations. Journal of Global Optimization, 59:633–662.\nWechsung A, Scott JK, Watson HAJ, and Barton PI. (2015). Reverse propagation of McCormick relaxations. Journal of Global Optimization, 63(1): 1-36.","category":"page"},{"location":"quick_start/qs_landing/#Quick-Start","page":"Quick Start","title":"Quick Start","text":"","category":"section"},{"location":"quick_start/qs_landing/","page":"Quick Start","title":"Quick Start","text":"EAGO is a global optimizer primarily meant to be used with the JuMP algebraic modeling language. Typical use will involve installing EAGO and JuMP, creating a problem using JuMP syntax, and passing the problem to the Optimizer. ","category":"page"},{"location":"quick_start/qs_landing/#Customization","page":"Quick Start","title":"Customization","text":"","category":"section"},{"location":"quick_start/qs_landing/","page":"Quick Start","title":"Quick Start","text":"EAGO is designed to be easily extensible. Some of the examples that follow include use cases where the standard EAGO functionality is overloaded and readily incorporated into the main optimization routine. Information on how to extend the main branch-and-bound functions (including lower and upper-bounding routines) can be found in the Customization Guidelines section.","category":"page"},{"location":"quick_start/qs_landing/#Examples","page":"Quick Start","title":"Examples","text":"","category":"section"},{"location":"quick_start/qs_landing/","page":"Quick Start","title":"Quick Start","text":"The following pages in this section include several representative examples of how EAGO can be used. Additional (and in some cases, shortened) examples can be found in the EAGO-notebooks repository. Examples and instructional pages in this section include:","category":"page"},{"location":"quick_start/qs_landing/","page":"Quick Start","title":"Quick Start","text":"Standard-Use Example 1: A base-case optimization problem solved using the EAGO optimizer. No extensions or function overloading required.\nStandard-Use Example 2: An interval bounding example where the user redefines EAGO's lower and upper-bounding functions.\nAdvanced-Use Example 1: A quasiconvex optimization problem solved by overloading some of EAGO's functionality to implement a bisection-based algorithm instead of typical branch-and-bound.\nAdvanced-Use Example 2: Overloading the branch-and-bound algorithm with a custom extension type.","category":"page"},{"location":"optimizer/relax_back/#Nonlinear-Backend","page":"Nonlinear Backend","title":"Nonlinear Backend","text":"","category":"section"},{"location":"optimizer/relax_back/#Graphs,-Caches,-Forward-and-Reverse-Propagation","page":"Nonlinear Backend","title":"Graphs, Caches, Forward and Reverse Propagation","text":"","category":"section"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":"EAGO makes use of a specialized tape structure for each function in order to compute valid composite bounds and relaxations. Each variable, constant, and expression is represented by a node in a directed graph structure. ","category":"page"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":" EAGO.Node\n EAGO.NodeClass\n EAGO.AtomType","category":"page"},{"location":"optimizer/relax_back/#EAGO.Node","page":"Nonlinear Backend","title":"EAGO.Node","text":"struct Node <: EAGO.AbstractNode\n\nDescribes connectivity and expression represented by node.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/#EAGO.NodeClass","page":"Nonlinear Backend","title":"EAGO.NodeClass","text":"NodeType\n\nEach node in the directed graph can be classified into the following types\n\nVARIABLE: Denotes a decision variable.\nPARAMETER: An adjustable parameter value (not a decision variable).\nCONSTANT: A constant value\nEXPRESSION: Any other expression that isn't a subexpression\nSUBEXPRESSION: Any expression referencing a different graph representation.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/#EAGO.AtomType","page":"Nonlinear Backend","title":"EAGO.AtomType","text":"AtomType\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":" EAGO.AbstractDirectedGraph\n EAGO.DirectedTree","category":"page"},{"location":"optimizer/relax_back/#EAGO.AbstractDirectedGraph","page":"Nonlinear Backend","title":"EAGO.AbstractDirectedGraph","text":"abstract type AbstractDirectedGraph\n\nAbstract supertype for generic directed graph structure.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/#EAGO.DirectedTree","page":"Nonlinear Backend","title":"EAGO.DirectedTree","text":"DirectedTree\n\nA tree graph with a single sink node.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":"Each field of the ith EAGO.Node using a basic access function. For instance the ith node's ex_type for graph d may be accessed by ex_type(d, i). The sparsity of node i returns an ordered list of children nodes which form the argument tuple for the operator performed at node i. The sparsity of node i returns a list of parent nodes which form the argument tuple for the operator performed at node i. The parameter_values and constant_values functions are used to access the ith parameter values or ith constant values.","category":"page"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":"EAGO organizes information associated with each node in a given graph structure using an EAGO.AbstractCache which stores the given information.","category":"page"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":" EAGO.AbstractCache\n EAGO.initialize!(::AbstractCache, ::AbstractDirectedGraph)","category":"page"},{"location":"optimizer/relax_back/#EAGO.AbstractCache","page":"Nonlinear Backend","title":"EAGO.AbstractCache","text":"abstract type AbstractCache\n\nAbstract supertype used for information storage object the directed acyclic graph.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/#EAGO.initialize!-Tuple{AbstractCache, AbstractDirectedGraph}","page":"Nonlinear Backend","title":"EAGO.initialize!","text":"initialize!(_::AbstractCache, _::AbstractDirectedGraph)\n\n\nFunction used to initialize the storage cache d::AbstractCache for a given type of directed acyclic graph g::AbstractDirectedGraph.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":"Information in a given EAGO.AbstractCache is populated by performing a series of forward and reverse passes of the graph structure which dispatch off of an EAGO.AbstractCacheAttribute which indicates what particular information is desired.","category":"page"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":" EAGO.AbstractCacheAttribute","category":"page"},{"location":"optimizer/relax_back/#EAGO.AbstractCacheAttribute","page":"Nonlinear Backend","title":"EAGO.AbstractCacheAttribute","text":"abstract type AbstractCacheAttribute\n\nAbstract supertype used for attributes stored in a cache.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":"Three included AbstractCacheAttributes are used to ","category":"page"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":" EAGO.Relax\n EAGO.RelaxAA\n EAGO.RelaxMulEnum","category":"page"},{"location":"optimizer/relax_back/#EAGO.Relax","page":"Nonlinear Backend","title":"EAGO.Relax","text":"Relax\n\nUsed to dispatch relaxations to a standard \n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/#EAGO.RelaxAA","page":"Nonlinear Backend","title":"EAGO.RelaxAA","text":"RelaxAA\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/#EAGO.RelaxMulEnum","page":"Nonlinear Backend","title":"EAGO.RelaxMulEnum","text":"RelaxMulEnum\n\n\n\n\n\n","category":"type"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":"The forward and reverse routines are overloaded as follows:","category":"page"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":" EAGO.f_init!(t::AbstractCacheAttribute, g::AbstractDirectedGraph, c::AbstractCache)\n EAGO.fprop!(t::AbstractCacheAttribute, v::Variable, g::AbstractDirectedGraph, c::AbstractCache, k::Int)\n EAGO.fprop!(t::AbstractCacheAttribute, v::Subexpression, g::AbstractDirectedGraph, c::AbstractCache, k::Int)\n EAGO.fprop!(t::AbstractCacheAttribute, v::Expression, g::AbstractDirectedGraph, c::AbstractCache, k::Int)\n EAGO.fprop!(t::AbstractCacheAttribute, v::Parameter, g::AbstractDirectedGraph, c::AbstractCache, k::Int)\n EAGO.fprop!(t::AbstractCacheAttribute, v::Constant, g::AbstractDirectedGraph, c::AbstractCache, k::Int)","category":"page"},{"location":"optimizer/relax_back/#EAGO.f_init!-Tuple{AbstractCacheAttribute, AbstractDirectedGraph, AbstractCache}","page":"Nonlinear Backend","title":"EAGO.f_init!","text":"Initializes information in cache c for each node in g that may be used in a forward-pass of attribute t. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Variable, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a variable v at index k in cache c associated with graph g using information at index k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Subexpression, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a subexpression v at index k in cache c associated with graph g using information taken from the children of k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Expression, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a expression v at index k in cache c associated with graph g using information taken from the children of k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Parameter, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a parameter v at index k in cache c associated with graph g using information at index k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Constant, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a constant v at index k in cache c associated with graph g using information at index k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":" EAGO.r_init!(t::AbstractCacheAttribute, g::AbstractDirectedGraph, c::AbstractCache)\n EAGO.rprop!(t::AbstractCacheAttribute, v::Variable, g::AbstractDirectedGraph, c::AbstractCache, k::Int)\n EAGO.rprop!(t::AbstractCacheAttribute, v::Subexpression, g::AbstractDirectedGraph, c::AbstractCache, k::Int)\n EAGO.rprop!(t::AbstractCacheAttribute, v::Expression, g::AbstractDirectedGraph, c::AbstractCache, k::Int)\n EAGO.rprop!(t::AbstractCacheAttribute, v::Parameter, g::AbstractDirectedGraph, c::AbstractCache, k::Int)\n EAGO.rprop!(t::AbstractCacheAttribute, v::Constant, g::AbstractDirectedGraph, c::AbstractCache, k::Int)","category":"page"},{"location":"optimizer/relax_back/#EAGO.r_init!-Tuple{AbstractCacheAttribute, AbstractDirectedGraph, AbstractCache}","page":"Nonlinear Backend","title":"EAGO.r_init!","text":"Initializes information in cache c for each node in g that may be used in a reverse-pass of attribute t. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Variable, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a variable v at index k in cache c associated with graph g using information at index k taken from the parents of k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Subexpression, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a subexpressions v at index k in cache c associated with graph g using information at index k taken from the parents of k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Expression, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a expressions v at index k in cache c associated with graph g using information at index k taken from the parents of k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Parameter, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a parameters v at index k in cache c associated with graph g using information at index k taken from the parents of k. \n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Constant, AbstractDirectedGraph, AbstractCache, Int64}","page":"Nonlinear Backend","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a constant v at index k in cache c associated with graph g using information at index k taken from the parents of k.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":"Forward and reverse subroutines are overloaded for individual operators using through functions of the forms fprop!(t::AbstractCacheAttribute, v::Val{AtomType}, g::AbstractDirectedGraph, b::AbstractCache, k::Int) and rprop!(t::AbstractCacheAttribute, v::Val{AtomType}, g::AbstractDirectedGraph, b::AbstractCache, k::Int). ","category":"page"},{"location":"optimizer/relax_back/#Other-Routines","page":"Nonlinear Backend","title":"Other Routines","text":"","category":"section"},{"location":"optimizer/relax_back/","page":"Nonlinear Backend","title":"Nonlinear Backend","text":" EAGO.is_safe_cut!(m::GlobalOptimizer, f::MathOptInterface.ScalarAffineFunction{Float64}) ","category":"page"},{"location":"optimizer/relax_back/#EAGO.is_safe_cut!-Tuple{GlobalOptimizer, MathOptInterface.ScalarAffineFunction{Float64}}","page":"Nonlinear Backend","title":"EAGO.is_safe_cut!","text":"is_safe_cut!(\n m::GlobalOptimizer,\n f::MathOptInterface.ScalarAffineFunction{Float64}\n) -> Bool\n\n\nApplies the safe cut checks detailed in Khajavirad, 2018 [Khajavirad, Aida, and Nikolaos V. Sahinidis. \"A hybrid LP/NLP paradigm for global optimization relaxations.\" Mathematical Programming Computation 10.3 (2018): 383-421] to ensure that only numerically safe affine relaxations are added. Checks that:\n\n|b| <= safe b, \nsafe_l <= abs(ai) <= safe u, and \nsafe_l <= abs(ai/aj) <= safe_u.\n\n\n\n\n\n","category":"method"},{"location":"mccormick/type/#Types","page":"Types","title":"Types","text":"","category":"section"},{"location":"mccormick/type/","page":"Types","title":"Types","text":"McCormick.MC\nMcCormick.RelaxTag","category":"page"},{"location":"mccormick/type/#McCormick.MC","page":"Types","title":"McCormick.MC","text":"struct MC{N, T<:RelaxTag} <: Real\n\nMC{N, T <: RelaxTag} <: Real is the McCormick (w/ (sub)gradient) structure which is used to overload standard calculations. The fields are:\n\ncv::Float64: Convex relaxation\ncc::Float64: Concave relaxation\nIntv::Interval{Float64}: Interval bounds\ncv_grad::SVector{N, Float64} where N: (Sub)gradient of convex relaxation\ncc_grad::SVector{N, Float64} where N: (Sub)gradient of concave relaxation\ncnst::Bool: Boolean indicating whether the relaxations are constant over the domain. True if bounding an interval/constant. False, otherwise. This may change over the course of a calculation cnst for zero(x) is true even if x.cnst is false.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/type/#McCormick.RelaxTag","page":"Types","title":"McCormick.RelaxTag","text":"abstract type RelaxTag\n\nAn abstract type the subtypes of which define the manner of relaxation that will be performed for each operator applied to the MC object. Currently, the struct NS which specifies that standard (Mitsos 2009) are to be used is fully supported. Limited support is provided for differentiable McCormick relaxations specified by struct Diff (Khan 2017) and struct MV struct MV (Tsoukalas 2011.) A rounding-safe implementation of the standard McCormick relaxations is specified by the struct NSSafe which is work in progress.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/type/#Constructors-for-MC","page":"Types","title":"Constructors for MC","text":"","category":"section"},{"location":"mccormick/type/","page":"Types","title":"Types","text":"MC{N,T}(y::Float64)","category":"page"},{"location":"mccormick/type/#McCormick.MC-Union{Tuple{Float64}, Tuple{T}, Tuple{N}} where {N, T}","page":"Types","title":"McCormick.MC","text":"MC{N,T}(y::Interval{Float64})\n\nConstructs a McCormick relaxation with the convex relaxation equal to y.lo and concave relaxation equal to y.hi.\n\n\n\n\n\nMC{N,T}(y::Float64)\n\nConstructs a McCormick relaxation with the convex relaxation equal to y and concave relaxation equal to y.\n\n\n\n\n\n","category":"method"},{"location":"mccormick/type/#Internal-Utilities","page":"Types","title":"Internal Utilities","text":"","category":"section"},{"location":"mccormick/type/","page":"Types","title":"Types","text":"mid3\nmid3v\nmid_grad\ndline_seg\nseed_gradient\ncut\nsecant\nnewton\nMcCormick.golden_section_it\nMcCormick.golden_section","category":"page"},{"location":"mccormick/type/#McCormick.mid3","page":"Types","title":"McCormick.mid3","text":"mid3(\n x::Float64,\n y::Float64,\n z::Float64\n) -> Tuple{Float64, Int64}\n\n\nCalculates the middle of three numbers returning the value and the index where x >= y.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.mid3v","page":"Types","title":"McCormick.mid3v","text":"mid3v(x::Float64, y::Float64, z::Float64) -> Float64\n\n\nCalculates the middle of three numbers (x,y,z) returning the value where x <= y.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.mid_grad","page":"Types","title":"McCormick.mid_grad","text":"mid_grad(\n cc_grad::SArray{Tuple{N}, Float64, 1, N},\n cv_grad::SArray{Tuple{N}, Float64, 1, N},\n id::Int64\n) -> Any\n\n\nTakes the concave relaxation gradient 'ccgrad', the convex relaxation gradient 'cvgrad', and the index of the midpoint returned 'id' and outputs the appropriate gradient according to McCormick relaxation rules.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.dline_seg","page":"Types","title":"McCormick.dline_seg","text":"dline_seg(\n f::Function,\n df::Function,\n x::Float64,\n xL::Float64,\n xU::Float64\n) -> Tuple{Any, Any}\n\n\nCalculates the value of the slope line segment between (xL, f(xL)) and (xU, f(xU)) defaults to evaluating the derivative of the function if the interval is tight.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.seed_gradient","page":"Types","title":"McCormick.seed_gradient","text":"seed_gradient(j::Int64, x::Val{N}) -> Any\n\n\nCreates a x::SVector{N,Float64} object that is one at x[j] and zero everywhere else.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.cut","page":"Types","title":"McCormick.cut","text":"cut(\n xL::Float64,\n xU::Float64,\n cv::Float64,\n cc::Float64,\n cv_grad::SArray{Tuple{N}, Float64, 1, N},\n cc_grad::SArray{Tuple{N}, Float64, 1, N}\n) -> Tuple{Float64, Float64, Any, Any}\n\n\nRefines convex/concave relaxations cv and cc with associated subgradients cv_grad and cc_grad by intersecting them with the interval boudns xL and xU.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.secant","page":"Types","title":"McCormick.secant","text":"secant(\n x0::Float64,\n x1::Float64,\n xL::Float64,\n xU::Float64,\n f::Function,\n envp1::Float64,\n envp2::Float64\n) -> Tuple{Float64, Bool}\n\n\nDefines a local 1D secant method to solve for the root of f between the bounds xL and xU using x0 and x1 as a starting points. The inputs envp1 and envp2 are the envelope calculation parameters.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.newton","page":"Types","title":"McCormick.newton","text":"newton(\n x0::Float64,\n xL::Float64,\n xU::Float64,\n f::Function,\n df::Function,\n envp1::Float64,\n envp2::Float64\n) -> Tuple{Any, Bool}\n\n\nDefines a local 1D newton method to solve for the root of f between the bounds xL and xU using x0 as a starting point. The derivative of f is df. The inputs envp1 and envp2 are the envelope calculation parameters.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.golden_section_it","page":"Types","title":"McCormick.golden_section_it","text":"golden_section_it(\n init::Int64,\n a::Float64,\n fa::Float64,\n b::Float64,\n fb::Float64,\n c::Float64,\n fc::Float64,\n f::Function,\n envp1::Float64,\n envp2::Float64\n) -> Float64\n\n\nDefine iteration used in golden section method. The inputs fa,fb, and fc, are the function f evaluated at a,b, and c respectively. The inputs envp1 and envp2 are the envelope calculation parameters. The value init is the iteration number of the golden section method.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#McCormick.golden_section","page":"Types","title":"McCormick.golden_section","text":"golden_section(\n xL::Float64,\n xU::Float64,\n f::Function,\n envp1::Float64,\n envp2::Float64\n) -> Float64\n\n\nDefines a local 1D golden section method to solve for the root of f between the bounds xL and xU using x0 as a starting point. Define iteration used in golden section method. The inputs envp1 and envp2 are the envelope calculation parameters.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/type/#(Under-Development)-MCNoGrad","page":"Types","title":"(Under Development) MCNoGrad","text":"","category":"section"},{"location":"mccormick/type/","page":"Types","title":"Types","text":"A handful of applications make use of McCormick relaxations directly without the need for subgradients. We are currently adding support for a McCormick struct which omits subgradient propagation in favor of return a MCNoGrad object and associated derivative information. This is currently under development and likely lacking key functionality.","category":"page"},{"location":"mccormick/type/","page":"Types","title":"Types","text":" McCormick.MCNoGrad\n MCNoGrad(y::Float64)\n MCNoGrad(y::Interval{Float64})\n MCNoGrad(cv::Float64, cc::Float64)","category":"page"},{"location":"mccormick/type/#McCormick.MCNoGrad","page":"Types","title":"McCormick.MCNoGrad","text":"struct MCNoGrad <: Real\n\nMCNoGrad <: Real is a McCormick structure without RelaxType Tag or subgradients. This structure is used for source-code transformation approaches to constructing McCormick relaxations. Methods definitions and calls should specify the relaxation type used (i.e.) +(::NS, x::MCNoGrad, y::MCNoGrad).... Moreover, the kernel associated with this returns all intermediate calculations necessary to compute subgradient information whereas the overloading calculation simply returns the MCNoGrad object. For univariate calculations without tiepoints such as we log2(::NS, x::MCNoGrad)::MCNoGrad whereas log2_kernel(::NS, x::MCNoGrad, ::Bool) = (::MCNoGrad, cv_id::Int, cc_id::Int, dcv, dcc). Univariate NS functions follow convention (MCNoGrad, cvid, ccid, dcv, dcc, tp1cv, tp1cc, .... tpncv, tpncc) where cv_id is the subgradient selected (1 = cv, 2 = cc, 3 = 0), dcv and dcc are derivatives (or elements of subdifferential) of the outside function evaluated per theorem at the point being evaluated and tpicv, tpicc are the ith tiepoints associated with computing the envelope of the outside function. .\n\ncv::Float64: Convex relaxation\ncc::Float64: Concave relaxation\nIntv::Interval{Float64}: Interval bounds\ncnst::Bool: Boolean indicating whether the relaxations are constant over the domain. True if bounding an interval/constant. False, otherwise. This may change over the course of a calculation cnst for zero(x) is true even if x.cnst is false.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/type/#McCormick.MCNoGrad-Tuple{Float64}","page":"Types","title":"McCormick.MCNoGrad","text":"MCNoGrad(y::Float64)\n\nConstructs McCormick relaxation with convex relaxation equal to y and concave relaxation equal to y.\n\n\n\n\n\n","category":"method"},{"location":"mccormick/type/#McCormick.MCNoGrad-Tuple{Interval{Float64}}","page":"Types","title":"McCormick.MCNoGrad","text":"MCNoGrad(y::Interval{Float64})\n\nConstructs McCormick relaxation with convex relaxation equal to y.lo and concave relaxation equal to y.hi.\n\n\n\n\n\n","category":"method"},{"location":"mccormick/type/#McCormick.MCNoGrad-Tuple{Float64, Float64}","page":"Types","title":"McCormick.MCNoGrad","text":"MCNoGrad(cv::Float64, cc::Float64)\n\nConstructs McCormick relaxation with convex relaxation equal to cv and concave relaxation equal to cc.\n\n\n\n\n\n","category":"method"},{"location":"examples/alpha_bb/#Advanced-Use-Example-2","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"","category":"section"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"This example is also provided here as a Jupyter Notebook.","category":"page"},{"location":"examples/alpha_bb/#An-\\alphaBB-Example-for-a-QCQP.","page":"Advanced-Use Example 2","title":"An alphaBB Example for a QCQP.","text":"","category":"section"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"In this example, we will demonstrate the use of a user-defined lower-bounding problem that uses alphaBB convex relaxations. In this example, we wish to solve the nonconvex quadratically constrained quadratic program (QCQP):","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"beginaligned\n min_mathbf x in mathbbIR^2 frac12 mathbf x^rm T mathbf Q_f mathbf x + mathbf c_f^rm T mathbf x \nrm st g_1(mathbf x) = frac12 mathbf x^rm T mathbf Q_g_1mathbf x + mathbf c_g_1^rm T mathbf x leq 0 \n g_2(mathbf x) = frac12 mathbf x^rm T mathbf Q_g_2 mathbf x + mathbf c_g_2^rm T mathbf x leq 0 \nendaligned","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"with mathbf Q_iinmathbb R^2times 2 not positive semidefinite for any i.","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"using JuMP, EAGO, Ipopt, LinearAlgebra","category":"page"},{"location":"examples/alpha_bb/#Custom-Function-Definitions","page":"Advanced-Use Example 2","title":"Custom Function Definitions","text":"","category":"section"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"For convenience, we'll define the following function that returns all the problem data mathbf Q_i and mathbf c_i.","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"function QCQP_setup()\n\n Qf = [3.0, 3/2; 3/2, -5.0]\n cf = [3.0; 2.0]\n\n Qg1 = [-2.0, 5.0; 5.0, -2.0]\n cg1 = [1.0; 3.0]\n\n Qg2 = [-6.0, 3.0; 3.0, 2.0]\n cg2 = [2.0; 1.0]\n \n return Qf, cf, Qg1, cg1, Qg2, cg2\nend","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"The next function we'll define will take as input data for a particular quadratic function and the interval bounds on the decision variables, and construct an alphaBB convex relaxation of that function. Since we're solving a QCQP, we'll use the eigvals function to directly compute the eigenvalues of the input mathbf Q_i matrix.","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"function αBB_relax(Q::Matrix{T}, c::Vector{T}, xL::Vector{T}, xU::Vector{T}, x::Real...) where {T<:Float64}\n α = max(0.0, -minimum(eigvals(Q))/2)\n y = [x[1]; x[2]]\n cv = 1/2*y'*Q*y + c'*y + α*(xL - y)'*(xU - y)\n return cv\nend","category":"page"},{"location":"examples/alpha_bb/#Redefine-the-Lower-Bounding-Problem","page":"Advanced-Use Example 2","title":"Redefine the Lower-Bounding Problem","text":"","category":"section"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"The following code first defines our EAGO extension (custom version) struct and then it redefines the lower-bounding problem as our own version. That is, when we call this customized version of EAGO to solve the problem, it'll deploy this version of the lower-bounding problem instead of the default version. ","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"import EAGO: Optimizer, GlobalOptimizer\n\nstruct αBB_Convex <: EAGO.ExtensionType end\nimport EAGO: lower_problem!\nfunction EAGO.lower_problem!(t::αBB_Convex, opt::GlobalOptimizer)\n # Get active node\n n = opt._current_node\n # Get bounds on active node for calculating relaxations\n xL = n.lower_variable_bounds[1:2]\n xU = n.upper_variable_bounds[1:2]\n # Get the problem data\n Qf, cf, Qg1, cg1, Qg2, cg2 = QCQP_setup()\n\n # Define the JuMP model and declare the solver\n mL = JuMP.Model(JuMP.optimizer_with_attributes(Ipopt.Optimizer,\n \"tol\" => 1.0e-6,\n \"print_level\" => 0))\n @variable(mL, xL[i] <= x[i=1:2] <= xU[i])\n \n # Define the function closures for the user-defined relaxations\n fcv(x...) = αBB_relax(Qf, cf, xL, xU, x...)\n g1cv(x...) = αBB_relax(Qg1, cg1, xL, xU, x...)\n g2cv(x...) = αBB_relax(Qg2, cg2, xL, xU, x...)\n\n # Register the user-defined functions\n # Note: If the gradients and Hessians are directly available, they could\n # be passed as arguments to the register function to speed things up.\n JuMP.register(mL, :fcv, 2, fcv, autodiff=true)\n JuMP.register(mL, :g1cv, 2, g1cv, autodiff=true)\n JuMP.register(mL, :g2cv, 2, g2cv, autodiff=true)\n\n # Declare the objective function and constraints\n @NLobjective(mL, Min, fcv(x[1], x[2]))\n @NLconstraint(mL, g1cv(x[1], x[2]) <= 0.0)\n @NLconstraint(mL, g2cv(x[1], x[2]) <= 0.0)\n \n # Solve the relaxed problem\n JuMP.optimize!(mL)\n \n # Get primal status, termination status, determine if a global solution was obtained\n tstatus = MOI.get(mL, MOI.TerminationStatus())\n pstatus = MOI.get(mL, MOI.PrimalStatus())\n\n solution = JuMP.value.(x)\n # Interpret status codes for branch-and-bound\n if EAGO.local_problem_status(tstatus, pstatus) == EAGO.LRS_FEASIBLE\n opt._lower_objective_value = JuMP.objective_value(mL) \n opt._lower_solution[1:length(solution)] = solution\n opt._lower_feasibility = true\n opt._cut_add_flag = false\n else\n opt._lower_feasibility = false\n opt._lower_objective_value = -Inf\n opt._cut_add_flag = false\n end\n return\nend","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"note: Note\nBy default, EAGO solves the epigraph reformulation of your original problem, which increases the original problem dimensionality by +1 with the introduction of an auxiliary variable. When defining custom routines (such as the lower-bounding problem here) that are intended to work nicely with default EAGO routines (such as preprocessing), the user must account for the new dimensionality of the problem. In the code above, we wish to access the information of the specific B&B node and define an optimization problem based on that information. However, in this example, the node has information for 3 variables (the original 2 plus 1 for the auxiliary variable appended to the original variable vector) as (x_1 x_2 eta). The lower-bounding problem was defined to optimize the relaxed problem with respect to the original 2 decision variables. When storing the results of this subproblem to the current B&B node, it is important to take care to store the information at the appropriate indices and not inadvertently redefine the problem dimensionality (i.e., by simply storing the optimization solution as the lower_solution of the current node). For problems that are defined to only branch on a subset of the original variables, the optimizer has a member _sol_to_branch_map that carries the mapping between the indices of the original variables to those of the variables being branched on. Visit our quasiconvex example to see how this is done.","category":"page"},{"location":"examples/alpha_bb/#(Optional)-Turn-Off-Processing-Routines","page":"Advanced-Use Example 2","title":"(Optional) Turn Off Processing Routines","text":"","category":"section"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"Turn off preprocessing routines if you don't want to use them as defined in EAGO. ","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"import EAGO: preprocess!\nfunction EAGO.preprocess!(t::αBB_Convex, x::GlobalOptimizer)\n x._preprocess_feasibility = true\n return\nend","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"Turn off postprocessing routines if you don't want to use them as defined in EAGO. ","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"import EAGO: postprocess!\nfunction EAGO.postprocess!(t::αBB_Convex, x::GlobalOptimizer)\n x._postprocess_feasibility = true\n return\nend","category":"page"},{"location":"examples/alpha_bb/#Construct-the-JuMP-Model-and-Optimize","page":"Advanced-Use Example 2","title":"Construct the JuMP Model and Optimize","text":"","category":"section"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"Now, we'll tell EAGO to use our custom/extended solver, set up the main JuMP model, and solve it with our custom solver. ","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"factory = () -> EAGO.Optimizer(SubSolvers(; t = αBB_Convex() ))\nm = JuMP.Model(optimizer_with_attributes(factory,\n \"relative_tolerance\" => 1e-3,\n \"verbosity\" => 1,\n \"output_iterations\" => 1, \n \"branch_variable\" => Bool[true; true],\n ))\nQf, cf, Qg1, cg1, Qg2, cg2 = QCQP_setup() # Get QCQP data\nxL = [-3.0; -5.0] # Lower bounds on x\nxU = [1.0; 2.0] # Upper bounds on x\n@variable(m, xL[i] <= x[i=1:2] <= xU[i])\n\n# Define objective and constraints\n@objective(m, Min, 1/2*x'*Qf*x + cf'*x)\n@constraint(m, 1/2*x'*Qg1*x + cg1'*x <= 0.0)\n@constraint(m, 1/2*x'*Qg2*x + cg2'*x <= 0.0)\n\n# Solve the problem\n@time optimize!(m)","category":"page"},{"location":"examples/alpha_bb/#Retrieve-Results","page":"Advanced-Use Example 2","title":"Retrieve Results","text":"","category":"section"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"We then recover the objective value, the solution values, and termination status codes using standard JuMP syntax.","category":"page"},{"location":"examples/alpha_bb/","page":"Advanced-Use Example 2","title":"Advanced-Use Example 2","text":"println(\"x1* = \", JuMP.value(x[1]), \" x2* = \",\n JuMP.value(x[2]),\" f* = \",JuMP.objective_value(m))\nTermStatus = JuMP.termination_status(m)\nPrimStatus = JuMP.primal_status(m)\nprintln(\"Algorithm terminated with a status of $TermStatus and result code of $PrimStatus\")","category":"page"},{"location":"optimizer/bnb_back/#EAGO's-Branch-and-Bound-Routine","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":"This component is meant to provide a flexible framework for implementing spatial branch-and-bound based optimization routines in Julia. All components of the branch-and-bound routine can be customized by the individual user: lower-bounding problem, upper-bounding problem.","category":"page"},{"location":"optimizer/bnb_back/#Branch-and-Bound-Node-Storage","page":"EAGO's Branch and Bound Routine","title":"Branch and Bound Node Storage","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.NodeBB","category":"page"},{"location":"optimizer/bnb_back/#EAGO.NodeBB","page":"EAGO's Branch and Bound Routine","title":"EAGO.NodeBB","text":"struct NodeBB\n\nStore information associated with each node in the branch-and-bound tree.\n\nlower_variable_bounds::Vector{Float64}: Lower bounds of variable box.\nupper_variable_bounds::Vector{Float64}: Upper bounds of variable box.\nis_integer::BitVector: Is dimension integer valued\ncontinuous::Bool: Are all dimensions continuous (or fixed)\nlower_bound::Float64: Lower bound of problem solution on nodeBB\nupper_bound::Float64: Upper bound of problem solution on nodeBB\ndepth::Int64: Depth of node in B&B tree.\ncont_depth::Int64: Depth of first parent in B&B tree that was continuously valued\nid::Int64: Unique ID for each node.\nbranch_direction::EAGO.BranchDirection: Whether last branch was negative or positive in direction\nlast_branch::Int64: Dimension of last branch\nbranch_extent::Float64: Extent of last branch (using for psuedocost calculation)\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":"The GlobalOptimizer structure holds all information relevant to branch-and-bound.","category":"page"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.GlobalOptimizer","category":"page"},{"location":"optimizer/bnb_back/#EAGO.GlobalOptimizer","page":"EAGO's Branch and Bound Routine","title":"EAGO.GlobalOptimizer","text":"mutable struct GlobalOptimizer{Q, S, T<:ExtensionType} <: MathOptInterface.AbstractOptimizer\n\nOptimizer internal to EAGO which holds information used to perform branch-and-bound in order to solve nonconvex MINLPs.\n\nDescriptions of all fields available in extended help.\n\nExtended Help\n\n_subsolvers::SubSolvers{Q, S} where {Q, S}: Storage for relaxed and upper optimizers to use, and any custom extensions\n_parameters::EAGOParameters: Parameters that do not change during a global solve\n_input_problem::InputProblem: Expressions and constraints added to the EAGO model (not directly used for relaxations)\n_working_problem::ParsedProblem: Expressions and problem descriptions that EAGO uses to formulate relaxed problems\n_auxiliary_variable_info::Union{Nothing, EAGO._AuxVarData}: Information on any auxiliary variables\nobbt_variable_values::Vector{Bool}: Variables to perform OBBT on (default: all variables in nonlinear expressions)\nenable_optimize_hook::Bool: Specifies that the optimize_hook! function should be called rather than throw the problem to the standard routine\next::Any: (Deprecated, use _subsolvers instead) Storage for custom extension types\n_end_state::EAGO.GlobalEndState: The completion status code for the branch-and-bound algorithm\n_termination_status_code::MathOptInterface.TerminationStatusCode: The MathOptInterface-compliant completion status code\n_result_status_code::MathOptInterface.ResultStatusCode: Value indicating the feasibility status of the result\n_obj_mult::Float64: Multiplier used internally to convert objective sense from Max to Min. Only takes on values of {-1.0, 1.0}\n_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!)\n_stack::DataStructures.BinaryMinMaxHeap{NodeBB}: A heap of all nodes in the branch-and-bound tree\n_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\n_first_relax_point_set::Bool: (Unused) Flag for relaxation points\n_current_xref::Vector{Float64}: (Unused) Variable values of a particular point\n_candidate_xref::Vector{Float64}: (Unused) Variable values of a candidate point\n_use_prior_objective_xref::Bool: (Unused) Flag to use variable values from previous evaluation on the current step\n_current_objective_xref::Vector{Float64}: (Unused) Variable values for objective evaluation\n_prior_objective_xref::Vector{Float64}: (Unused) Variable values for previous objective evaluation\n_user_branch_variables::Bool: Flag for if the user has specified branch variables (see label_branch_variables!)\n_fixed_variable::Vector{Bool}: Variables that are fixed in place\n_branch_variable_count::Int64: Number of variables that can be branched on\n_branch_to_sol_map::Vector{Int64}: Mapping from the branch variables to the full set of variables in the problem\n_sol_to_branch_map::Vector{Int64}: Mapping from the full set of variables in the problem to the branch variables\n_continuous_solution::Vector{Float64}: The final (or intermediate) variable values of the solution\n_preprocess_feasibility::Bool: Flag to ensure preprocessing result is feasible\n_preprocess_termination_status::MathOptInterface.TerminationStatusCode: Status codes for use in bounds tightening\n_preprocess_primal_status::MathOptInterface.ResultStatusCode: Status codes for use in bounds tightening\n_preprocess_dual_status::MathOptInterface.ResultStatusCode: Status codes for use in bounds tightening\n_lower_primal_status::MathOptInterface.ResultStatusCode: Primal status of the lower problem\n_lower_dual_status::MathOptInterface.ResultStatusCode: Dual status of the lower problem\n_lower_termination_status::MathOptInterface.TerminationStatusCode: Termination status of the lower problem\n_lower_feasibility::Bool: Flag for lower problem feasibility\n_lower_objective_value::Float64: Objective value result from the lower problem\n_lower_solution::Vector{Float64}: Variable values of the lower problem solution\n_lower_lvd::Vector{Float64}: Lower variable duals for use in duality-based bound tightening\n_lower_uvd::Vector{Float64}: Upper variable duals for use in duality-based bound tightening\n_last_cut_objective::Float64: Objective value associated with the previous cut in the cutting planes algorithm\n_upper_result_status::MathOptInterface.ResultStatusCode: Primal status of the upper problem\n_upper_termination_status::MathOptInterface.TerminationStatusCode: Termination status of the upper problem\n_upper_feasibility::Bool: Flag for upper problem feasibility\n_upper_objective_value::Float64: Objective value result from the upper problem\n_upper_variables::Vector{MathOptInterface.VariableIndex}: \n_upper_solution::Vector{Float64}: \n_postprocess_feasibility::Bool: (Unused) Flag to ensure postprocessing result is feasible\n_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!\n_start_time::Float64: Storage for the time() when optimization began\n_run_time::Float64: Current run time, incremented using time()-_start_time\n_parse_time::Float64: A field to keep track of time spent on initial problem parsing\n_presolve_time::Float64: Used in optimize_nonconvex.jl to track how long the presolve step takes\n_last_preprocess_time::Float64: Updated each iteration to track the time of the preprocess step\n_last_lower_problem_time::Float64: Updated each iteration to track the time of the lower problem step\n_last_upper_problem_time::Float64: Updated each iteration to track the time of the upper problem step\n_last_postprocessing_time::Float64: Updated each iteration to track the time of the postprocess step\n_min_converged_value::Float64: A field to track convergence progress across iterations\n_global_lower_bound::Float64: The best-known lower bound\n_global_upper_bound::Float64: The best-known upper bound\n_maximum_node_id::Int64: The total number of nodes that have been created\n_iteration_count::Int64: The number of iterations the branch-and-bound algorithm has completed\n_node_count::Int64: The number of nodes in the stack\n_solution_value::Float64: (Unused) The best-known solution value\n_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\n_solution_node::Int64: The node ID of the best-known feasible upper problem solution (default = -1, if no feasible solution is found)\n_best_upper_value::Float64: The best-known upper bound\n_obbt_working_lower_index::Vector{Bool}: Indices of variables to perform OBBT on\n_obbt_working_upper_index::Vector{Bool}: Indices of variables to perform OBBT on\n_lower_indx_diff::Vector{Bool}: Tracker for changes in obbtworkinglowerindex across iterations\n_upper_indx_diff::Vector{Bool}: Tracker for changes in obbtworkingupperindex across iterations\n_old_low_index::Vector{Bool}: Storage for indices prior to OBBT step\n_old_upp_index::Vector{Bool}: Storage for indices prior to OBBT step\n_new_low_index::Vector{Bool}: New indices following OBBT step; compared with _old_low_index\n_new_upp_index::Vector{Bool}: New indices following OBBT step; compared with _old_upp_index\n_obbt_variables::Vector{MathOptInterface.VariableIndex}: (Deprecated) Variables to perform OBBT on. Replaced by _obbt_working_lower_index and _obbt_working_upper_index\n_obbt_variable_count::Int64: The number of variables to perform OBBT on\n_obbt_performed_flag::Bool: (Unused) Flag to indicate whether OBBT has been performed\n_lower_fbbt_buffer::Vector{Float64}: Buffer for FBBT lower bounds. Set in presolve, used in preprocess\n_upper_fbbt_buffer::Vector{Float64}: Buffer for FBBT upper bounds. Set in presolve, used in preprocess\n_cp_improvement::Float64: (Unused) Improvement in constraint propagation\n_cp_evaluation_reverse::Bool: (Unused) Flag for if constraint propagation results need to be reversed\n_cut_iterations::Int64: Iterations of the cutting planes algorithm completed\n_cut_add_flag::Bool: (Unused) Flag to check if cuts should be added\n_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\n_log::Log: Storage for logging information during a branch-and-bound run\n_affine_relax_ci::Vector{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}}: Storage for affine constraints\n_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\n_relaxed_variable_number::Int64: (Unused) Number of relaxed variables\n_relaxed_variable_index::Vector{MathOptInterface.VariableIndex}: Indices of relaxed variables\n_relaxed_variable_et::Vector{Tuple{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.EqualTo{Float64}}, Int64}}: Stored EqualTo constraints\n_relaxed_variable_lt::Vector{Tuple{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}, Int64}}: Stored LessThan constraints\n_relaxed_variable_gt::Vector{Tuple{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}, Int64}}: Stored GreaterThan constraints\n_relaxed_variable_integer::Vector{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.Integer}}: Stored Integer constraints\n_branch_variables::Vector{Bool}: List of variables that can be branched on. If not user-specified, branch variables are identified in label_branch_variables!\n_nonbranching_int::Bool: (Unused) Flag for non-branching integers\n_new_eval_constraint::Bool: Flag indicating if an initial evaluation of the constraints has occurred\n_new_eval_objective::Bool: Flag indicating if the objective expression was evaluated\n_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!\n_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!\n_nonlinear_evaluator_created::Bool: Flag to check for nonlinear evaluators. Set to true in add_nonlinear_evaluator!\n_branch_cost::EAGO.BranchCostStorage{Float64}: (FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED) Storage for pseudocost branching\n_branch_variable_sparsity::SparseArrays.SparseMatrixCSC{Bool, Int64}: (FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED) Sparsity information of the branch variables\n_constraint_infeasiblity::Vector{Float64}: (FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED) Information on the infeasibility of each constraint\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#Customizable-Subroutines","page":"EAGO's Branch and Bound Routine","title":"Customizable Subroutines","text":"","category":"section"},{"location":"optimizer/bnb_back/#Stack-Management-Subroutines","page":"EAGO's Branch and Bound Routine","title":"Stack Management Subroutines","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.branch_node!(t::ExtensionType, m::GlobalOptimizer)\n EAGO.select_branch_variable(t::ExtensionType, m::GlobalOptimizer)\n EAGO.select_branch_point(t::ExtensionType, m::GlobalOptimizer, i)\n EAGO.node_selection!(t::ExtensionType, m::GlobalOptimizer)\n EAGO.fathom!(t::ExtensionType, m::GlobalOptimizer)\n EAGO.initialize_stack!(t::ExtensionType, m::GlobalOptimizer)\n EAGO.single_storage!(t::ExtensionType, m::GlobalOptimizer)","category":"page"},{"location":"optimizer/bnb_back/#EAGO.branch_node!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.branch_node!","text":"branch_node!(t::ExtensionType, m::GlobalOptimizer)\n\n\nCreate two nodes from current_node and store them on the stack. Call select_branch_variable(t, m) and select_branch_point(t, m, k) to determine the variable that should be branched on and the point at which branching should occur, respectively.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.select_branch_variable-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.select_branch_variable","text":"select_branch_variable(\n t::ExtensionType,\n m::GlobalOptimizer\n) -> Any\n\n\nChoose a variable to branch on. A maximum relative width branching rule is used by default.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.select_branch_point-Tuple{ExtensionType, GlobalOptimizer, Any}","page":"EAGO's Branch and Bound Routine","title":"EAGO.select_branch_point","text":"select_branch_point(\n t::ExtensionType,\n m::GlobalOptimizer,\n i\n) -> Float64\n\n\nSelect a point xb within the domain of the ith branching variable. By default, this point is a convex combination of the solution to the relaxation and the midpoint of the node (branch_cvx_factor*xmid + (1-branch_cvx_factor)*xsol). If the solution lies within branch_offset of a bound, then the branch point is moved to a distance of branch_offset from that bound.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.node_selection!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.node_selection!","text":"node_selection!(t::ExtensionType, m::GlobalOptimizer)\n\n\nSelect the next node in the stack to evaluate. By default, perform best-first node selection (select the node with the lowest lower bound in the stack).\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.fathom!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.fathom!","text":"fathom!(t::ExtensionType, m::GlobalOptimizer)\n\n\nRemove nodes from the stack. By default, delete nodes from the stack if their lower bounds are greater than the current global upper bound.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.initialize_stack!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.initialize_stack!","text":"initialize_stack!(t::ExtensionType, m::GlobalOptimizer)\n\n\nPrepare the stack for the branch-and-bound routine. By default, create an initial node with the variable bounds as box constraints and add it to the stack.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.single_storage!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.single_storage!","text":"single_storage!(t::ExtensionType, m::GlobalOptimizer)\n\n\nStore the current node to the stack, without branching, after updating lower/upper bounds.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#Internal-Subproblem-Status-Codes-and-Subsolver-Management","page":"EAGO's Branch and Bound Routine","title":"Internal Subproblem Status Codes and Subsolver Management","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.RelaxResultStatus\n EAGO.LocalResultStatus\n EAGO.Incremental\n EAGO.SubSolvers\n EAGO.set_default_config!(t::ExtensionType, m::GlobalOptimizer)","category":"page"},{"location":"optimizer/bnb_back/#EAGO.RelaxResultStatus","page":"EAGO's Branch and Bound Routine","title":"EAGO.RelaxResultStatus","text":"RelaxResultStatus\n\nStatus code used internally to determine how to interpret the results from the solution of a relaxed problem.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.LocalResultStatus","page":"EAGO's Branch and Bound Routine","title":"EAGO.LocalResultStatus","text":"LocalResultStatus\n\nStatus code used internally to determine how to interpret the results from the solution of a local problem solve.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.Incremental","page":"EAGO's Branch and Bound Routine","title":"EAGO.Incremental","text":"mutable struct Incremental{S<:MathOptInterface.AbstractOptimizer} <: MathOptInterface.AbstractOptimizer\n\nA 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. \n\n(Deprecated) For Q = Val{true}, the subsolver supports incremental loading. For Q = Val{false}, the subsolver does not.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.SubSolvers","page":"EAGO's Branch and Bound Routine","title":"EAGO.SubSolvers","text":"mutable struct SubSolvers{Q<:MathOptInterface.AbstractOptimizer, S<:MathOptInterface.AbstractOptimizer, T<:ExtensionType}\n\nA structure containing the relaxed and upper optimizers to be used, as well as any user-defined extension.\n\nrelaxed_optimizer::MathOptInterface.AbstractOptimizer: Optimizer used to solve relaxed subproblems. Set using r = [...] (<: MOI.AbstractOptimizer) (default = Cbc.Optimizer())\nupper_optimizer::MathOptInterface.AbstractOptimizer: Optimizer used to solve upper bounding problems. Set using u = [...] (<: MOI.AbstractOptimizer) (default = Ipopt.Optimizer())\next::ExtensionType: User-defined extension to use. Set using t = [...](<: EAGO.ExtensionType)\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.set_default_config!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.set_default_config!","text":"set_default_config!\n\nConfigures subsolver tolerances based on tolerance parameters provided to EAGO (provided that a specialized subsolver configuration routine has been provided and m.user_solver_config = false).\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#Main-Subproblem-and-Termination-Subroutines","page":"EAGO's Branch and Bound Routine","title":"Main Subproblem and Termination Subroutines","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.convergence_check(t::ExtensionType, m::GlobalOptimizer)\n EAGO.cut_condition(t::ExtensionType, m::GlobalOptimizer)\n EAGO.lower_problem!(t::ExtensionType, m::GlobalOptimizer{R,S,Q}) where {R,S,Q<:ExtensionType}\n EAGO.preprocess!(t::ExtensionType, m::GlobalOptimizer{R,S,Q}) where {R,S,Q<:ExtensionType}\n EAGO.postprocess!(t::ExtensionType, m::GlobalOptimizer)\n EAGO.repeat_check(t::ExtensionType, m::GlobalOptimizer)\n EAGO.termination_check(t::ExtensionType, m::GlobalOptimizer)\n EAGO.upper_problem!(t::ExtensionType, m::GlobalOptimizer)\n EAGO.parse_global!(t::ExtensionType, m::GlobalOptimizer)\n EAGO.optimize_hook!(t::ExtensionType, m::Optimizer)","category":"page"},{"location":"optimizer/bnb_back/#EAGO.convergence_check-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.convergence_check","text":"convergence_check(\n t::ExtensionType,\n m::GlobalOptimizer\n) -> Bool\n\n\nCheck for problem convergence.\n\nBy default, check if the lower and upper bounds have converged to within absolute and/or relative tolerances.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.cut_condition-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.cut_condition","text":"cut_condition(t::ExtensionType, m::GlobalOptimizer) -> Bool\n\n\nReturns true if a cut should be added and computes a new reference point to add the cut at. By default, checks that cut_max_iterations are not exceeded and that the improvement in the objective value associated with the previous cut is greater than both an absolute tolerance cut_ϵ_abs and a relative tolerance cut_ϵ_rel. Returns false otherwise.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.lower_problem!-Union{Tuple{Q}, Tuple{S}, Tuple{R}, Tuple{ExtensionType, GlobalOptimizer{R, S, Q}}} where {R, S, Q<:ExtensionType}","page":"EAGO's Branch and Bound Routine","title":"EAGO.lower_problem!","text":"lower_problem!(\n t::ExtensionType,\n m::GlobalOptimizer{R, S, Q<:ExtensionType}\n)\n\n\nConstructs a relaxation of the MINLP on node y and solves it using the default EAGO relaxation scheme. By default, EAGO applies Kelley's algorithm (from Kelley Jr., J.E.: The cutting-plane method for solving convex programs. J. Soc. Ind. Appl. Math. 8(4), 703 to 712 (1960)) while cut_condition(m) returns true then activates the integrality constraints of the relaxed problems and solves the resulting MILP relaxation. results are stored to the _lower_solution, _lower_termination_status, _lower_primal_status, _lower_dual_status, _lower_objective_value, and _lower_feasibility. Further, lower and upper variable duals are stored _lower_lvd and _lower_uvd, respectively, for use in duality based bound tightening. If relaxation-based bounds are weaker or cutting-planes are numerically poorly ill-posed, then interval bounds are used instead. If the problem is dual feasible but the primal status is ambiguous the dual objective value is used for the lower bound to avoid numerical issues.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.preprocess!-Union{Tuple{Q}, Tuple{S}, Tuple{R}, Tuple{ExtensionType, GlobalOptimizer{R, S, Q}}} where {R, S, Q<:ExtensionType}","page":"EAGO's Branch and Bound Routine","title":"EAGO.preprocess!","text":"preprocess!(\n t::ExtensionType,\n m::GlobalOptimizer{R, S, Q<:ExtensionType}\n)\n\n\nRuns contractor methods prior to solving lower bounding problem. By default linear and quadratic contractor methods followed by interval constraint propagation then optimization-based bound tightening for a specified number of iterations while the subproblem at current node n has not been proven infeasible.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.postprocess!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.postprocess!","text":"postprocess!(t::ExtensionType, m::GlobalOptimizer)\n\n\nDefault postprocess perfoms duality-based bound tightening (Tawarmalani, M., Sahinidis, N.V.: Global optimization of mixed-integer nonlinear programs: a theoretical and computational study. Math. Progr. 99, 563–591 (2004).) up to an iteration limit set by dbbt_depth.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.repeat_check-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.repeat_check","text":"repeat_check(t::ExtensionType, m::GlobalOptimizer) -> Bool\n\n\nCheck to see if current node should be reprocessed. Without any custom extension, return false by default.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.termination_check-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.termination_check","text":"termination_check(m::GlobalOptimizer)\ntermination_check(t::ExtensionType, m::GlobalOptimizer) -> Bool\n\nCheck for termination of the branch-and-bound algorithm.\n\nIf only the GlobalOptimizer is given as an argument, termination_check dispatches to the other form using the ExtensionType given in the SubSolvers. If there is no user-defined extension, then by default, this will check for satisfaction of absolute or relative tolerances, solution infeasibility, and other specified limits. Returns true if any conditions are met and branch-and-bound should end, and false otherwise.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.upper_problem!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.upper_problem!","text":"upper_problem!(t::ExtensionType, m::GlobalOptimizer)\n\n\nDefault upper bounding problem which simply calls solve_local_nlp! to solve the NLP locally.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.parse_global!-Tuple{ExtensionType, GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.parse_global!","text":"Basic parsing for global solutions (no extensive manipulation). By default, does nothing.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.optimize_hook!-Tuple{ExtensionType, Optimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.optimize_hook!","text":"optimize_hook!(t::ExtensionType, m::Optimizer)\n\nProvide a hook for extensions to EAGO. \n\nThe user-defined extension of optimize_hook! is used in EAGO's overloading of MOI.optimize! (see EAGO.jl/src/eago_optimizer/optimize/optimize.jl). Without the optimize_hook! specified, EAGO will run initial_parse!, parse_classify_problem!, and then optimize! using the parsed problem type. The user-specified optimize_hook! should thus take the new extension and Optimizer as inputs and will execute when the user writes optimize!(model).\n\nExample\n\nHere, optimize_hook! is used to bypass EAGO's problem parsing and treat every problem using its branch-and-bound routine. This is done in this example by telling EAGO to treat the problem as a mixed integer nonconvex problem, which normally dispatches to branch-and-bound.\n\nstruct MyNewExtension <: EAGO.ExtensionType end\nimport EAGO: optimize_hook!\nfunction EAGO.optimize_hook!(t::MyNewExtension, m::Optimizer)\n initial_parse!(m)\n optimize!(EAGO.MINCVX(), m)\nend\n\nThe same functionality could be accomplished by setting the EAGOParameter field force_global_solve to be true.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#Internal-Subroutines","page":"EAGO's Branch and Bound Routine","title":"Internal Subroutines","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.is_integer_subproblem(m)\n EAGO.is_integer_feasible_local(m::GlobalOptimizer, d)\n EAGO.is_integer_feasible_relaxed(m::GlobalOptimizer)\n EAGO.interval_bound\n EAGO.lower_interval_bound\n EAGO.same_box(x::NodeBB,y::NodeBB, atol::Float64)\n EAGO.solve_local_nlp!(x::Optimizer)\n EAGO.set_dual!(x::Optimizer)\n EAGO.update_relaxed_problem_box!\n EAGO.reform_epigraph_min!(m::GlobalOptimizer)\n EAGO.label_fixed_variables!(m::GlobalOptimizer)\n EAGO.label_branch_variables!(m::GlobalOptimizer)\n EAGO.add_nonlinear!(m::GlobalOptimizer)\n EAGO.parse_classify_problem!(m::GlobalOptimizer)\n EAGO.local_problem_status(t::MathOptInterface.TerminationStatusCode, r::MathOptInterface.ResultStatusCode)","category":"page"},{"location":"optimizer/bnb_back/#EAGO.is_integer_subproblem-Tuple{Any}","page":"EAGO's Branch and Bound Routine","title":"EAGO.is_integer_subproblem","text":"is_integer_subproblem(m)\n\n\nReturns true that the subproblem at the current node n has participating integer variables that have not been fixed to constant valued as the branch-and-bound algorithm progresses. Returns false otherwise.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.is_integer_feasible_local-Tuple{GlobalOptimizer, Any}","page":"EAGO's Branch and Bound Routine","title":"EAGO.is_integer_feasible_local","text":"is_integer_feasible_local(m::GlobalOptimizer, d) -> Bool\n\n\nChecks that the solution of a local solve is integer feasible to within the tolerances specified by integer_abs_tol and integer_rel_tol.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.is_integer_feasible_relaxed-Tuple{GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.is_integer_feasible_relaxed","text":"is_integer_feasible_relaxed(m::GlobalOptimizer) -> Bool\n\n\nCheck that the solution of the lower (relaxed problem) is integer feasible to within tolerances specified by the parameters: integer_abs_tol (absolute tolerance) and integer_rel_tol (relative tolerance).\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.interval_bound","page":"EAGO's Branch and Bound Routine","title":"EAGO.interval_bound","text":"interval_bound(::GlobalOptimizer, ::T)\n\nCompute a tuple representing the lower and upper interval bounds for an AbstractEAGOConstraint representing an equality constraint.\n\nOptions for T (all are subtypes of AbstractEAGOConstraint):\n\nAffineFunctionEq\nAffineFunctionIneq\nBufferedQuadraticEq\nBufferedQuadraticIneq\nBufferedNonlinearFunction{V,N,T} where {V,N,T}\n\n\n\n\n\n","category":"function"},{"location":"optimizer/bnb_back/#EAGO.lower_interval_bound","page":"EAGO's Branch and Bound Routine","title":"EAGO.lower_interval_bound","text":"lower_interval_bound(::GlobalOptimizer, ::T)\n\nCompute the lower interval bound for an AbstractEAGOConstraint representing an inequality constraint.\n\nOptions for T (all are subtypes of AbstractEAGOConstraint):\n\nAffineFunctionIneq\nBufferedQuadraticIneq\nBufferedSOC\nBufferedNonlinearFunction{V,N,T} where {V,N,T}\n\n\n\n\n\n","category":"function"},{"location":"optimizer/bnb_back/#EAGO.same_box-Tuple{NodeBB, NodeBB, Float64}","page":"EAGO's Branch and Bound Routine","title":"EAGO.same_box","text":"same_box(x::NodeBB, y::NodeBB, r::Float64) -> Bool\n\n\nCheck that node x and y have equal domains within an absolute tolerance of r.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.solve_local_nlp!-Tuple{Optimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.solve_local_nlp!","text":"Constructs and solves the problem locally on node y updated the upper solution informaton in the optimizer.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.set_dual!-Tuple{Optimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.set_dual!","text":"set_dual!(m)\n\n\nRetrieves the lower and upper duals for variable bounds from the relaxed_optimizer and sets the appropriate values in the _lower_lvd and _lower_uvd storage fields.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.update_relaxed_problem_box!","page":"EAGO's Branch and Bound Routine","title":"EAGO.update_relaxed_problem_box!","text":"update_relaxed_problem_box!(m)\n\n\nUpdate the relaxed constraint by setting the constraint set of v == x* , xL_i <= x_i, and x_i <= xU_i for each such constraint added to the relaxed optimizer. Resets integral valued constraints to either EqualTo or Interval constraints.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/bnb_back/#EAGO.reform_epigraph_min!-Tuple{GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.reform_epigraph_min!","text":"reform_epigraph_min!(m::GlobalOptimizer)\n\n\nPerform an epigraph reformulation assuming the working_problem is a minimization problem.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.label_fixed_variables!-Tuple{GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.label_fixed_variables!","text":"label_fixed_variables!(m::GlobalOptimizer) -> Vector{Bool}\n\n\nDetect any variables set to a fixed value by equality or inequality constraints and populate the _fixed_variable storage array.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.label_branch_variables!-Tuple{GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.label_branch_variables!","text":"label_branch_variables!(m::GlobalOptimizer)\n\n\nDetect any variables participating in nonconvex terms and populate the _branch_variables storage array.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.add_nonlinear!-Tuple{GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.add_nonlinear!","text":"add_nonlinear!(m::GlobalOptimizer)\n\n\nAdd an Evaluator and nonlinear functions and populate each appropriately.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.parse_classify_problem!-Tuple{GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.parse_classify_problem!","text":"parse_classify_problem!(m::GlobalOptimizer)\n\nInterprets the type/number of constraints and the type of objective function to infer a problem type. Current possible types include:\n\nLP: Linear program; sent to optimize_lp.jl\n'MILP: Mixed integer linear program; sent tooptimize_lp.jl`\nSOCP: Second-order cone program; sent to optimize_conic.jl\nMINCVX: Mixed-integer nonconvex; sent to optimize_nonconvex.jl\n\nIf the force_global_solve parameter is set to true, parse_classify_problem! will set the problem type to MINCVX to pass the problem to optimize_nonconvex.jl.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#EAGO.local_problem_status-Tuple{MathOptInterface.TerminationStatusCode, MathOptInterface.ResultStatusCode}","page":"EAGO's Branch and Bound Routine","title":"EAGO.local_problem_status","text":"local_problem_status(t, r)\n\n\nTakes an MOI.TerminationStatusCode and a MOI.ResultStatusCode and returns true if this corresponds to a solution that is proven to be feasible. Returns false otherwise.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#Functions-for-Generating-Console-Output","page":"EAGO's Branch and Bound Routine","title":"Functions for Generating Console Output","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.print_iteration!\n EAGO.print_node!\n EAGO.print_results!\n EAGO.print_solution!","category":"page"},{"location":"optimizer/bnb_back/#EAGO.print_iteration!","page":"EAGO's Branch and Bound Routine","title":"EAGO.print_iteration!","text":"print_iteration!\n\nPrint status information based on iteration count. The header print frequency is based on the header_iterations setting, and the data print frequency is based on the output_iterations setting.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/bnb_back/#EAGO.print_node!","page":"EAGO's Branch and Bound Routine","title":"EAGO.print_node!","text":"print_node!\n\nPrint information about the current node. Includes node ID, lower bound, upper bound, and interval box.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/bnb_back/#EAGO.print_results!","page":"EAGO's Branch and Bound Routine","title":"EAGO.print_results!","text":"print_results!(m::GlobalOptimizer, lower_flag::Bool)\n\n\nPrint the results of a single (lower or upper) bounding problem. lower_flag=true prints information for the lower problem, lower_flag=false prints information for the upper problem.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/bnb_back/#EAGO.print_solution!","page":"EAGO's Branch and Bound Routine","title":"EAGO.print_solution!","text":"print_solution!\n\nPrint solution information for the B&B problem. Display node with the best solution, solution value, solution, and time spent solving subproblems. This print occurs following termination of the B&B algorithm.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/bnb_back/#Support-for-Log-Output-at-Each-Iteration","page":"EAGO's Branch and Bound Routine","title":"Support for Log Output at Each Iteration","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.Log\n EAGO.log_iteration!(x::GlobalOptimizer)","category":"page"},{"location":"optimizer/bnb_back/#EAGO.Log","page":"EAGO's Branch and Bound Routine","title":"EAGO.Log","text":"mutable struct Log\n\nA structure used to store information on the history of the solution procedure for generating convergence plots and other analyses.\n\ncurrent_lower_bound::Vector{Float64}: Storage for lower bound calculated for current node.\ncurrent_upper_bound::Vector{Float64}: Storage for upper bound calculated for current node.\npreprocessing_time::Vector{Float64}: Storage for preprocessing time of each iteration.\nlower_problem_time::Vector{Float64}: Storage for lower bounding time of each iteration.\nupper_problem_time::Vector{Float64}: Storage for upper bounding time of each iteration.\npostprocessing_time::Vector{Float64}: Storage for postprocessing time of each iteration.\npreprocessing_feas::Vector{Bool}: Storage for preprocessing feasibility of each iteration.\nlower_problem_feas::Vector{Bool}: Storage for lower bounding feasibility of each iteration.\nupper_problem_feas::Vector{Bool}: Storage for upper bounding feasibility of each iteration.\npostprocessing_feas::Vector{Bool}: Storage for postprocessing feasibility of each iteration.\nglobal_lower_bound::Vector{Float64}: Storage for best (global) lower bound at each iteration.\nglobal_upper_bound::Vector{Float64}: Storage for best (global) upper bound at each iteration.\nnode_count::Vector{Int64}: Number of nodes at each iteration.\nrun_time::Vector{Float64}: Run time at each iteration.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.log_iteration!-Tuple{GlobalOptimizer}","page":"EAGO's Branch and Bound Routine","title":"EAGO.log_iteration!","text":"log_iteration!(m::GlobalOptimizer)\n\n\nIf log_on is true, the global_lower_bound, global_upper_bound, run_time, and node_count are stored every log_interval. If log_subproblem_info then the lower bound, feasibility and run times of the subproblems are logged every log_interval.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/bnb_back/#Interval-Representations-of-Expressions","page":"EAGO's Branch and Bound Routine","title":"Interval Representations of Expressions","text":"","category":"section"},{"location":"optimizer/bnb_back/","page":"EAGO's Branch and Bound Routine","title":"EAGO's Branch and Bound Routine","text":" EAGO.AbstractEAGOConstraint\n EAGO.AffineFunctionEq\n EAGO.AffineFunctionIneq\n EAGO.BufferedQuadraticIneq\n EAGO.BufferedQuadraticEq\n EAGO.NonlinearExpression\n EAGO.BufferedNonlinearFunction","category":"page"},{"location":"optimizer/bnb_back/#EAGO.AbstractEAGOConstraint","page":"EAGO's Branch and Bound Routine","title":"EAGO.AbstractEAGOConstraint","text":"abstract type AbstractEAGOConstraint\n\nAn abstract super-type used for representing constraints built by EAGO's backend.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.AffineFunctionEq","page":"EAGO's Branch and Bound Routine","title":"EAGO.AffineFunctionEq","text":"mutable struct AffineFunctionEq <: EAGO.AbstractEAGOConstraint\n\nRepresentation of an affine equality. Currently only used for bound tightening.\n\nterms::Vector{Tuple{Float64, Int64}}\nconstant::Float64\nlen::Int64\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.AffineFunctionIneq","page":"EAGO's Branch and Bound Routine","title":"EAGO.AffineFunctionIneq","text":"mutable struct AffineFunctionIneq <: EAGO.AbstractEAGOConstraint\n\nRepresentation of an affine inequality. Currently only used for bound tightening.\n\nterms::Vector{Tuple{Float64, Int64}}\nconstant::Float64\nlen::Int64\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.BufferedQuadraticIneq","page":"EAGO's Branch and Bound Routine","title":"EAGO.BufferedQuadraticIneq","text":"mutable struct BufferedQuadraticIneq <: EAGO.AbstractEAGOConstraint\n\nRepresentation of a general quadratic inequality constraint with a buffer.\n\nfunc::MathOptInterface.ScalarQuadraticFunction{Float64}\nbuffer::Dict{Int64, Float64}\nsaf::MathOptInterface.ScalarAffineFunction{Float64}\nlen::Int64\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.BufferedQuadraticEq","page":"EAGO's Branch and Bound Routine","title":"EAGO.BufferedQuadraticEq","text":"mutable struct BufferedQuadraticEq <: EAGO.AbstractEAGOConstraint\n\nRepresentation of a general quadratic equality constraint with a buffer.\n\nfunc::MathOptInterface.ScalarQuadraticFunction{Float64}\nminus_func::MathOptInterface.ScalarQuadraticFunction{Float64}\nbuffer::Dict{Int64, Float64}\nsaf::MathOptInterface.ScalarAffineFunction{Float64}\nlen::Int64\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.NonlinearExpression","page":"EAGO's Branch and Bound Routine","title":"EAGO.NonlinearExpression","text":"mutable struct NonlinearExpression{V, N, T<:RelaxTag} <: EAGO.AbstractEAGOConstraint\n\nStores a general quadratic function with a buffer.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/bnb_back/#EAGO.BufferedNonlinearFunction","page":"EAGO's Branch and Bound Routine","title":"EAGO.BufferedNonlinearFunction","text":"mutable struct BufferedNonlinearFunction{V, N, T<:RelaxTag} <: EAGO.AbstractEAGOConstraint\n\nStores a general nonlinear function with a buffer represented by the sum of a tape and a scalar affine function.\n\n\n\n\n\n","category":"type"},{"location":"custom_guidelines/#Customization-Guidelines","page":"Customization","title":"Customization Guidelines","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"This section contains general guidelines on how the functionality of EAGO can be extended for specific use cases. Many functions in EAGO are extensible, so examples are not provided for every possible case, but some important functions are covered. If there is a use case you do not see provided here, but would like to see, please contact Robert Gottlieb.","category":"page"},{"location":"custom_guidelines/#)-Creating-an-Extension","page":"Customization","title":"1) Creating an Extension","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"Extensibility in EAGO is based on the ExtensionType. To create customized functions, the recommended method is to create a new structure, as follows:","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"using EAGO\n\nstruct MyNewStruct <: EAGO.ExtensionType end","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"To let EAGO know that you would like to use this extension (and any functions you overload), when you create the JuMP model, declare your new type in the subsolver_block field of the Optimizer as follows:","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"using JuMP\n\nfactory = () -> EAGO.Optimizer(SubSolvers(; t = MyNewStruct() ))\nmodel = Model(factory)","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"The key point to note here is that the new structure is set to SubSolvers.t, which is the field that holds any user-defined extension type. Now, when EAGO calls any of its functions, it will check to see if a custom function for this new extension has been created. If so, it will use the new one; if not, it will use the default version of that function.","category":"page"},{"location":"custom_guidelines/#)-Preprocessing","page":"Customization","title":"2) Preprocessing","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"In EAGO's branch-and-bound routine, preprocessing is performed prior to solving the lower and upper problems. By default, linear and quadratic contractor methods are performed, followed by interval constraint propagation, then optimization-based bounds tightening. An important outcome of EAGO's default preprocessing is that the _preprocess_feasibility field of the GlobalOptimizer is set to true, unless the subproblem at the current node has been proven infeasible. Therefore, to bypass preprocessing for your own problem, you must, at a minimum, set this field to true. For example:","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"import EAGO: preprocess!\nfunction EAGO.preprocess!(t::MyNewStruct, x::EAGO.GlobalOptimizer)\n x._preprocess_feasibility = true\nend","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"The user-defined preprocessing step can be as simple or complex as desired, but if _preprocess_feasibility is not set to true, EAGO will assume each node is infeasible.","category":"page"},{"location":"custom_guidelines/#)-Lower-Problem","page":"Customization","title":"3) Lower Problem","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"By default, EAGO applies Kelley's cutting-plane algorithm [1] to solve the lower-problem. This can be overloaded using the same syntax as for the other functions. Necessary changes to the GlobalOptimizer that occur within the lower problem are changing the _lower_objective_value and _lower_feasibility fields. If the _lower_objective_value field is not changed, branch-and-bound will not update the lower bound. If _lower_feasibility is not set to true, the node will be discarded as infeasible. A minimum functional (though not useful) lower problem extension is as follows:","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"import EAGO: lower_problem!\nfunction EAGO.lower_problem!(t::MyNewStruct, x::EAGO.GlobalOptimizer)\n x._lower_objective_value = -Inf\n x._lower_feasibility = true\nend","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"Any arbitrarily complex lower problem can be substituted here in place of EAGO's default method, as long as these fields are updated. Note also that, although there is a separate upper problem function, if the lower problem is being replaced by an algorithm that also calculates an upper objective value, the necessary fields to update in upper_problem! can simply be updated here, and the upper_problem! can be overloaded by a function that does nothing.","category":"page"},{"location":"custom_guidelines/#)-Upper-Problem","page":"Customization","title":"4) Upper Problem","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"By default, the upper-bounding problem is run on every node up to depth upper_bounding_depth, and is triggered with a probability of 0.5^(depth - upper_bounding_depth) afterwards for continuous problems. For integer problems, this approach is used in addition to running on every node up to depth upper_bounding_depth + cont_depth, with another trigger of probability 0.5^(depth - upper_bounding_depth - cont_depth). The upper_bounding_depth and cont_depth are fields of EAGOParameters and can be changed from their default values when the JuMP model is created, or at any time afterwards. If any of these trigger conditions are met, the default EAGO upper problem runs a local NLP solve. ","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"The important fields to update in the upper_problem! are the _upper_objective_value and _upper_feasibility fields. If _upper_objective_value is not updated, the upper bound in the branch-and-bound algorithm will not update and the problem will not converge. If _upper_feasibility is not set to true, then any changes made to _upper_objective_value will not be updated for each node and the problem will not converge. A minimum functional (though not useful) upper problem extension is as follows:","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"import EAGO: upper_problem!\nfunction upper_problem!(t::MyNewStruct, x::EAGO.GlobalOptimizer)\n x._upper_objective_value = Inf\n x._upper_feasibility = true\nend","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"This example upper problem will set the upper bound on the objective value to Inf for each node. Given that no useful information is provided here, we could also have set x_upper_feasibility to false (or equivalently, remove the line where we set it to true), and the global upper bound would never be updated.","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"Note that if the _upper_objective_value is changed elsewhere, such as in the definition for the lower_problem!, the _upper_feasibility flag must be set to true. If this is not done, the change to the _upper_objective_value will be discarded.","category":"page"},{"location":"custom_guidelines/#)-Convergence-Check","page":"Customization","title":"5) Convergence Check","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"By default, EAGO checks to see if the lower and upper bounds have converged to within either the absolute or relative tolerance. This method of checking convergence may not be desired if, for example, only the absolute tolerance is relevant, and you want to ensure that the program does not end prematurely due to a relative tolerance limit being reached. The fields to check are _lower_objective_value and _upper_objective_value for the best-identified global lower and upper bounds, respectively. This function should return true if the lower and upper bounds have converged, and false otherwise. An example of how to specify that the convergence check only use the absolute tolerance is as follows:","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"import EAGO: convergence_check\nfunction EAGO.convergence_check(t::MyNewStruct, x::EAGO.GlobalOptimizer)\n gap = (x._upper_objective_value - x._lower_objective_value)\n return (gap <= x._parameters.absolute_tolerance)\nend","category":"page"},{"location":"custom_guidelines/#)-Postprocessing","page":"Customization","title":"6) Postprocessing","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"Postprocessing is the final step before a node is branched on. By default, EAGO performs duality-based bounds tightening [2] up to an iteration limit set by dbbt_depth in the EAGOParameters field. The important field to update in postprocessing is _postprocess_feasibility, which must be set to true for EAGO to branch on any given node. The minimum working postprocessing function is therefore:","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"import EAGO: postprocess!\nfunction EAGO.postprocess!(t::MyNewStruct, x::EAGO.GlobalOptimizer)\n x._postprocess_feasibility = true\nend","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"If _postprocess_feasibility is not set to true, no nodes will be branched on.","category":"page"},{"location":"custom_guidelines/#)-Termination-Check","page":"Customization","title":"7) Termination Check","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"This is the check that occurs on each iteration of the branch-and-bound algorithm that determines whether the algorithm continues or not. By default, several conditions are checked for such as the satisfaction of absolute or relative tolerances, solution infeasibility, or other specified limits. This function returns true if any of the stopping conditions have been met, and branch-and-bound should stop, and false otherwise. The important fields to update are _end_state, which takes values of EAGO.GlobalEndState, _termination_status_code, which takes values of MOI.TerminationStatusCode, and _result_status_code, which takes values of MOI.ResultStatusCode. Combined, these fields provide information about the branch-and-bound completion status and result feasibility. ","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"As an example, suppose we have updated the convergence_check function to only check for absolute tolerance, and based on our knowledge of the problem, this is the only condition we care about, and we know the solution will be optimal. We could then overload the termination_check function as follows:","category":"page"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"import EAGO: termination_check\nfunction EAGO.termination_check(t::MyNewStruct, x::EAGO.GlobalOptimizer)\n flag = EAGO.convergence_check(t, x)\n if flag\n x._end_state = EAGO.GS_OPTIMAL\n x._termination_status_code = MathOptInterface.OPTIMAL\n x._result_status_code = MathOptInterface.FEASIBLE_POINT\n end\n return flag\nend","category":"page"},{"location":"custom_guidelines/#References","page":"Customization","title":"References","text":"","category":"section"},{"location":"custom_guidelines/","page":"Customization","title":"Customization","text":"Kelley, J. E. “The Cutting-Plane Method for Solving Convex Programs.” Journal of the Society for Industrial and Applied Mathematics, vol. 8, no. 4, pp. 703–12 (1960). \nTawarmalani, M., Sahinidis, N. V. \"Global optimization of mixed-integer nonlinear programs: A theoretical and computational study.\" Math. Program., Ser. A, 99, pp. 563-591 (2004).","category":"page"},{"location":"optimizer/high_performance/#High-Performance-Configuration","page":"High-Performance Configuration","title":"High-Performance Configuration","text":"","category":"section"},{"location":"optimizer/high_performance/#Linear-Programming-Solver-Selection","page":"High-Performance Configuration","title":"Linear Programming Solver Selection","text":"","category":"section"},{"location":"optimizer/high_performance/","page":"High-Performance Configuration","title":"High-Performance Configuration","text":"By default, EAGO uses GLPK for solving linear subproblems introduced. Using a commercial linear programming (LP) solver is highly recommended, such as Gurobi, CPLEX, or XPRESS. Both Gurobi and CPLEX are free for academics and installation information can be found on the Gurobi website and the IBM website, respectively.","category":"page"},{"location":"optimizer/high_performance/","page":"High-Performance Configuration","title":"High-Performance Configuration","text":"A non-default LP solver can then be selected by the user via a series of keyword argument inputs as illustrated in the code snippet below. The relaxed_optimizer contains an instance optimizer with valid relaxations that are made at the root node and is updated with affine relaxations in place.","category":"page"},{"location":"optimizer/high_performance/","page":"High-Performance Configuration","title":"High-Performance Configuration","text":"# Create opt EAGO Optimizer with Gurobi as a lower subsolver\neago_factory = () -> EAGO.Optimizer(SubSolvers(; r = Gurobi.Optimizer()))\nm = Model(eago_factory)","category":"page"},{"location":"optimizer/high_performance/#Rounding-Mode","page":"High-Performance Configuration","title":"Rounding Mode","text":"","category":"section"},{"location":"optimizer/high_performance/","page":"High-Performance Configuration","title":"High-Performance Configuration","text":"The IntervalArithmetic.jl package supports a number of different directed rounding modes. The default directed rounding mode is :tight. It is recommended that the user specify that :accurate directed rounding mode be used as it may results in a significant performance improvement. Setting a rounding mode can requires the redefinition of a number of functions. As a result, this should only be done at the top-level by the user (rather than by using keyword arguments). To set the rounding mode to :accurate using the following syntax when loading the EAGO package initially:","category":"page"},{"location":"optimizer/high_performance/","page":"High-Performance Configuration","title":"High-Performance Configuration","text":"using IntervalArithmetic; setrounding(Interval, :accurate)\nusing EAGO\n# REST OF CODE","category":"page"},{"location":"optimizer/high_performance/#Ipopt-Build","page":"High-Performance Configuration","title":"Ipopt Build","text":"","category":"section"},{"location":"optimizer/high_performance/","page":"High-Performance Configuration","title":"High-Performance Configuration","text":"Ipopt is the recommended solver for upper-bounding problems. Ipopt's performance is highly dependent on the linear algebra package used (up to 30x). By default MUMPS is used. It is recommended that you either compile Ipopt with HSL MA57 or the Pardiso linear algebra packages with a machine specific Blas library (for Intel users the JuliaPro MKL version is recommended). For information on this, see the links below:","category":"page"},{"location":"optimizer/high_performance/","page":"High-Performance Configuration","title":"High-Performance Configuration","text":"Compiling Ipopt\nJulia specifics:\nPointing Ipopt to a compiled version:\nIpopt Package Info\nDiscourse discussion\nIssues using Pardiso:\nUbuntu\nWindows\nHSL website\nPardiso website","category":"page"},{"location":"dev/future/#Future-Work","page":"Future Work","title":"Future Work","text":"","category":"section"},{"location":"dev/future/#Current-Activity","page":"Future Work","title":"Current Activity","text":"","category":"section"},{"location":"dev/future/","page":"Future Work","title":"Future Work","text":"Update CI testing.\nSpecialized algorithms for relaxing ODE constrained problems and solving global and robust optimization problems.\nExtensions for nonconvex dynamic global & robust optimization.\nProvide support for mixed-integer problems.\nUpdate EAGO to support nonsmooth problems (requires: a nonsmooth local nlp optimizer or lexicographic AD, support for relaxations is already included).\nEvaluation and incorporation of implicit relaxation routines in basic solver.","category":"page"},{"location":"dev/future/#Other-Things-on-the-Wishlist-(But-Not-Actively-Being-Worked-On)","page":"Future Work","title":"Other Things on the Wishlist (But Not Actively Being Worked On)","text":"","category":"section"},{"location":"dev/future/","page":"Future Work","title":"Future Work","text":"Implement the interval constraint propagation scheme presented in Vu 2008. For improved convergences.\nA parametric bisection routine will be updated that can divide the (X P) space into a series of boxes that all contain unique branches of the implicit function p - y(p).\nProvide a better interface the nonconvex semi-infinite programs solvers (JuMPeR extension?).\nAdd additional McCormick relaxations.\nAdd handling for domain reduction of special expression forms.","category":"page"},{"location":"examples/explicit_ann/#Standard-Use-Example-1","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"","category":"section"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"This example is also provided here as a Jupyter Notebook.","category":"page"},{"location":"examples/explicit_ann/#Solving-an-ANN-to-Optimality-in-EAGO","page":"Standard-Use Example 1","title":"Solving an ANN to Optimality in EAGO","text":"","category":"section"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"In [1, 2], a surrogate artificial neural network (ANN) model of bioreactor productivity was constructed by fitting results from computationally expensive computational fluid dynamics (CFD) simulations. The authors then optimized this surrogate model to obtain ideal processing conditions. The optimization problem is given by:","category":"page"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"beginaligned\nmax_mathbf x in X B_2 + sum_r = 1^3 W_2r frac21 + exp (-2y_r + B_1r) rm where y_r = sum_i = 1^8 W_1ir x_i\nendaligned","category":"page"},{"location":"examples/explicit_ann/#Input-Parameters","page":"Standard-Use Example 1","title":"Input Parameters","text":"","category":"section"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"In the first block, we input parameters values supplied in the paper for W_1, W_2, B_1, and B_2 into Julia as simple array objects. We also input bounds for the variables which are used to scale the values obtained from optimization from -1 1 back into the design values.","category":"page"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"using JuMP, EAGO\n\n# Weights associated with the hidden layer\nW1 = [0.54, -1.97, 0.09, -2.14, 1.01, -0.58, 0.45, 0.26;\n -0.81, -0.74, 0.63, -1.60, -0.56, -1.05, 1.23, 0.93;\n -0.11, -0.38, -1.19, 0.43, 1.21, 2.78, -0.06, 0.40]\n\n# Weights associated with the output layer\nW2 = [-0.91, 0.11, 0.52]\n\n# Bias associated with the hidden layer\nB1 = [-2.698, 0.012, 2.926]\n\n# Bias associated with the output layer\nB2 = -0.46\n\n# Variable bounds (Used to scale variables after optimization)\nxLBD = [0.623, 0.093, 0.259, 6.56, 1114.0, 0.013, 0.127, 0.004]\nxUBD = [5.89, 0.5, 1.0, 90.0, 25000.0, 0.149, 0.889, 0.049]","category":"page"},{"location":"examples/explicit_ann/#Construct-the-JuMP-Model-and-Optimize","page":"Standard-Use Example 1","title":"Construct the JuMP Model and Optimize","text":"","category":"section"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"We now formulate the problem using standard JuMP [3] syntax and optimize it. Note that we are using the @NLexpression macro to handle the summation term to keep the code visually simple, but this could be placed directly in the @NLobjective macro instead.","category":"page"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"# Model construction\nmodel = Model(optimizer_with_attributes(EAGO.Optimizer, \"absolute_tolerance\" => 0.001))\n@variable(model, -1.0 <= x[i=1:8] <= 1.0)\n@NLexpression(model, y[r=1:3], sum(W1[r,i]*x[i] for i in 1:8))\n@NLobjective(model, Max, B2 + sum(W2[r]*(2.0/(1 + exp(-2.0*y[r] + B1[r]))) for r=1:3))\n\n# Solve the model\noptimize!(model)","category":"page"},{"location":"examples/explicit_ann/#Retrieve-Results","page":"Standard-Use Example 1","title":"Retrieve Results","text":"","category":"section"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"We then recover the objective value, the solution values, and termination status codes using standard JuMP syntax. The optimal value and solution values are then rescaled using the variable bounds to obtain their physical interpretations.","category":"page"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"# Access calculated values\nfval = JuMP.objective_value(model)\nxsol = JuMP.value.(x)\nstatus_term = JuMP.termination_status(model)\nstatus_prim = JuMP.primal_status(model)\nprintln(\"EAGO terminated with a status of $status_term and a result code of $status_prim.\")\nprintln(\"The optimal value is: $(round(fval, digits=5)).\")\nprintln(\"The solution found is $(round.(xsol, digits=3)).\")\nprintln(\" \")\n\n# Rescale values back to physical space\nrescaled_fval = ((fval + 1.0)/2.0)*0.07\nrescaled_xsol = ((xsol .+ 1.0)./2.0).*(xUBD - xLBD) .+ xLBD\nprintln(\"Rescaled optimal value and solution values:\")\nprintln(\"The rescaled optimal value is: $(round(rescaled_fval, digits=4))\")\nprintln(\"The rescaled solution is $(round.(rescaled_xsol, digits=3)).\")","category":"page"},{"location":"examples/explicit_ann/#References","page":"Standard-Use Example 1","title":"References","text":"","category":"section"},{"location":"examples/explicit_ann/","page":"Standard-Use Example 1","title":"Standard-Use Example 1","text":"J. D. Smith, A. A. Neto, S. Cremaschi, and D. W. Crunkleton, CFD-based optimization of a flooded bed algae bioreactor, Industrial & Engineering Chemistry Research, 52 (2012), pp. 7181–7188.\nA. M. Schweidtmann and A. Mitsos. Global Deterministic Optimization with Artificial Neural Networks Embedded https://arxiv.org/pdf/1801.07114.pdf.\nIain Dunning and Joey Huchette and Miles Lubin. JuMP: A Modeling Language for Mathematical Optimization, SIAM Review, 59 (2017), pp. 295-320.","category":"page"},{"location":"news/#News-for-EAGO-Releases","page":"News","title":"News for EAGO Releases","text":"","category":"section"},{"location":"news/#[v0.8.1](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.8.1)-(June-15,-2023)","page":"News","title":"v0.8.1 (June 15, 2023)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Resolved an issue where integer and binary variables would sometimes throw a MathOptInterface.UpperBoundAlreadySet error.\nAdded the function unbounded_check! which warns users if they are missing variable bounds and sets them to +/- 1E10 by default.\nAdded an EAGO parameter unbounded_check which defaults to true and enables unbounded_check!.\nBumped requirement for PrettyTables.jl to v2+ to accommodate the latest version of DataFrames.jl.","category":"page"},{"location":"news/#[v0.8.0](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.8.0)-(June-12,-2023)","page":"News","title":"v0.8.0 (June 12, 2023)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Updated EAGO for compatibility with the nonlinear expression API changes introduced in JuMP v1.2: https://discourse.julialang.org/t/ann-upcoming-refactoring-of-jumps-nonlinear-api/83052.\nEAGO now uses the MOI.Nonlinear submodule instead of JuMP._Derivatives.\nModels, nodes, expressions, constraints, and operators are now compatible with MOI.\nAdded logic and comparison operators to EAGO.OperatorRegistry.","category":"page"},{"location":"news/#[v0.7.3](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.7.3)-(April-11,-2023)","page":"News","title":"v0.7.3 (April 11, 2023)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Bumped DocStringExtensions.jl compatibility.","category":"page"},{"location":"news/#[v0.7.2](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.7.2)-(November-22,-2022)","page":"News","title":"v0.7.2 (November 22, 2022)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Added support for Julia 1.7.\nBumped NaNMath.jl compatibility.\nAdded help? information for various functions and structures.\nUpdated documentation and some formatting.","category":"page"},{"location":"news/#[v0.7.1](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.7.1)-(June-26,-2022)","page":"News","title":"v0.7.1 (June 26, 2022)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Added the function print_problem_summary, an internal script used to display all constraints, objectives in a linear program which is added to functions for debug purposes while writing code.\nAdjusted default EAGOParameters.\nbranch_cvx_factor: 0.5 => 0.25\nbranch_offset: 0.2 => 0.15\ntime_limit and _time_left: 1000.0 => 3600.0\nobbt_depth: 0 => 6\nobbt_repetitions: 1 => 3\ncut_tolerance_rel: 1E-2 => 1E-3\nAdjusted Ipopt.Optimizer attributes.\nmax_iter: 20000 => 10000\nacceptable_iter: 10000 => 1000\nExcluded test_quadratic_nonconvex_constraint_basic from MOI tests.\nRestricted JuMP compatibility to 1.0.0 - 1.1.1.","category":"page"},{"location":"news/#[v0.7.0](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.7.0)-(March-28,-2022)","page":"News","title":"v0.7.0 (March 28, 2022)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Added envelopes of activation functions: xabsx, logcosh\nAdded variations of estimator_extrema, estimator_under, and estimator_over functions to EAGO for bilinear relaxations.\nMoved various functions and related structures to new files.\nAdded RelaxCache structure to hold relaxed problem information.\nUpdated forward and reverse propagation.\nAdded PrettyTables.jl.\nAdded test examples.\nAdded a memory allocation analysis.\nUpdated documentation.","category":"page"},{"location":"news/#[v0.6.1](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.6.1)-(March-4,-2021)","page":"News","title":"v0.6.1 (March 4, 2021)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Minor update to tests.","category":"page"},{"location":"news/#[v0.6.0](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.6.0)-(February-19,-2021)","page":"News","title":"v0.6.0 (February 19, 2021)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"License changed from CC BY-NC-SA 4.0 to MIT.\nFix deprecated Ipopt constructor.\nFix discrepancy between the returned objective value and the objective evaluated at the solution.\nDramatically decrease allocates and first-run performance of SIP routines.\nAdd two algorithms which modify SIPRes detailed in Djelassi, H. and Mitsos A. 2017.\nFix objective interval fallback function.\nNew SIP interface with extendable subroutines.\nFix x^y relaxation bug.\nAdd issues template.\nAdd SIP subroutine documentation.","category":"page"},{"location":"news/#[v0.5.2](https://github.com/PSORLab/EAGO.jl/commit/bc59c5a8a5e26960c159e06e7b26e2e5c2472956)-(November-18,-2020)","page":"News","title":"v0.5.2 (November 18, 2020)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Fix user specified branching variables.","category":"page"},{"location":"news/#[v0.5.1](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.5.1)-(November-18,-2020)","page":"News","title":"v0.5.1 (November 18, 2020)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Support for Julia ~1 (with limited functionality for Julia 1.0 and 1.1).","category":"page"},{"location":"news/#[v0.5.0](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.5.0)-(November-18,-2020)","page":"News","title":"v0.5.0 (November 18, 2020)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Introduces the register_eago_operators!(m::JuMP.Model) which can be used to register all nonstandard nonlinear terms used in EAGO in any JuMP model.\nIntroduces positive, negative, lower_bnd, upper_bnd, and bnd functions which can be used to enforce bounds on intermediate terms in nonlinear expressions (EAGO.Optimizer only).\nAdds envelopes: abs2, sinpi, cospi, fma, cbrt\nAdds envelopes and functions: xlogx\nAdds envelopes of special functions: erf, erfc, erfinv, erfcinv\nAdds envelopes of activation functions: relu, gelu, elu, selu, swish, sigmoid, softsign, softplus, bisigmoid, pentanh, leaky_relu, param_relu\nError messages in sip_explicit have been made more transparent.\nFixes some issues with documentation image rendering and links.\nDrops appveyor CI and Travis CI in favor of GitHub Actions.","category":"page"},{"location":"news/#[v0.4.2](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.4.2)-(August-28,-2020)","page":"News","title":"v0.4.2 (August 28, 2020)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Support for Julia 1.5.","category":"page"},{"location":"news/#[v0.4.1](https://github.com/PSORLab/EAGO.jl/commit/9c1bcf024a19840a0ac49c8c6da13619a5f3845f#comments)-(June-17,-2020)","page":"News","title":"v0.4.1 (June 17, 2020)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Minor bug fixes.","category":"page"},{"location":"news/#[v0.4.0](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.4.0)-(June-12,-2020)","page":"News","title":"v0.4.0 (June 12, 2020)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Support for new MOI/JuMP RawParameter input and a number of new attributes.\nSeparates McCormick and ReverseMcCormick libraries (now McCormick.jl and ReverseMcCormick.jl) from main package. McCormick.jl is reexported.\nRelaxation calculations now return NaN values on a domain violation.\nTolerance based validation of cuts has been added to generate numerically safe cuts.\nSignificantly simplify internal codebase for EAGO.Optimizer (no changes to API): fully decouples input problem specifications from the formulation used internally, stack only stores variables that are branched on, and a number of internal rearrangements to clearly delineate different routines.\nAdd problem classification preprocessing that throws to simpler routines if LP problem types are detected (enables future support for SOCP, MILP, MISOCP, and Convex forms).\nFix multiple bugs and add more transparent error codes.","category":"page"},{"location":"news/#[v0.3.1](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.3.1)-(January-29,-2020)","page":"News","title":"v0.3.1 (January 29, 2020)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Add unit tests.\nSupport for Julia 1.3.\nFix IntervalContractors.jl dependency issue.","category":"page"},{"location":"news/#[v0.3.0](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.3.0)-(November-5,-2019)","page":"News","title":"v0.3.0 (November 5, 2019)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"This update is intended to be the last to create a large number of breaking changes to the EAGO API. Please review the use cases provided in the documentation to update examples.","category":"page"},{"location":"news/","page":"News","title":"News","text":"A number of performance improvements have been made to the underlying McCormick relaxation library.\nThe optimizer used to construct relaxations is now modified in place.\nAll subproblem storage has been moved to the Optimizer object and storage types (e.g. LowerInfo) have been removed.\nA BinaryMinMaxHeap structure is now used to store nodes.\nSpeed and aesthetics for logging and printing utilities have been updated.\nSubroutines are now customized by creating a subtype of ExtensionType and defining subroutines which dispatch on this new structure.\nParametric interval methods and the Implicit optimizer have been move to a separate package (to be tagged shortly).\nJIT compilation time has been reduced substantially.\nSupport for silent tag and time limits.","category":"page"},{"location":"news/#[v0.2.1](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.2.1)-(July-7,-2019)","page":"News","title":"v0.2.1 (July 7, 2019)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Bug fix for explicit SIP solving routine that occurred for uncertainty sets of dimension greater than 1.\nBug fix for MOI.MAX_SENSE (max objective sense).","category":"page"},{"location":"news/#[v0.2.0](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.2.0)-(June-14,-2019)","page":"News","title":"v0.2.0 (June 14, 2019)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"This update creates a number of breaking changes to the EAGO API. Please review the use cases provided in the documentation to update examples.","category":"page"},{"location":"news/","page":"News","title":"News","text":"Updated to support Julia 1.0+, MathOptInterface (MOI), and MOI construction of subproblems.\nAdditional domain reduction routines available.\nSupport for specialized handling of linear and quadratic terms.\nSignificant performance improvements due to pre-allocation of Wengert tapes and MOI support.\nA more intuitive API for McCormick relaxation construction.","category":"page"},{"location":"news/#[v0.1.2](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.1.2)-(June-20,-2018)","page":"News","title":"v0.1.2 (June 20, 2018)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Significant speed and functionality updates.","category":"page"},{"location":"news/#[v0.1.1](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.1.1)-(June-7,-2018)","page":"News","title":"v0.1.1 (June 7, 2018)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Initial release of combined EAGO packages.","category":"page"},{"location":"news/#[v0.1.0](https://github.com/PSORLab/EAGO.jl/releases/tag/v0.1.0)-(April-10,-2018)","page":"News","title":"v0.1.0 (April 10, 2018)","text":"","category":"section"},{"location":"news/","page":"News","title":"News","text":"Main global solver release.","category":"page"},{"location":"mccormick/overview/#Overview","page":"Overview","title":"Overview","text":"","category":"section"},{"location":"mccormick/overview/","page":"Overview","title":"Overview","text":"EAGO provides a library of McCormick relaxations in native Julia code. The EAGO optimizer supports relaxing functions using nonsmooth McCormick relaxations (Mitsos2009, Scott2011), smooth McCormick relaxations (Khan2016, Khan2018, Khan2019), and multi-variant McCormick relaxations (Tsoukalas2014; a variant of subgradient-based interval refinement (Najman2017)). For functions with arbitrarily differentiable relaxations, the differentiable constant μ can be modified by adjusting a constant value in the package. Additionally, validated and nonvalidated interval bounds are supported via IntervalArithmetic.jl which is reexported. The basic McCormick operator and reverse McCormick operator (Wechsung2015) libraries are included in two dependent subpackages which can loaded and used independently:","category":"page"},{"location":"mccormick/overview/","page":"Overview","title":"Overview","text":"McCormick.jl: A forward McCormick operator library\nReverseMcCormick.jl: A reverse McCormick operator library","category":"page"},{"location":"mccormick/overview/#NaN-Numerics","page":"Overview","title":"NaN Numerics","text":"","category":"section"},{"location":"mccormick/overview/","page":"Overview","title":"Overview","text":"When a relaxation is computed at an undefined point or over an unbounded domain, the resulting relaxation is defined as \"not a number\" (NaN) rather than throwing an error. This allows algorithms to check for these cases without resorting to try-catch statements. Moreover, when the interval domain is extensive enough to cause a domain violation, an x::MC structure is returned that satisfies isnan(x) === true.","category":"page"},{"location":"mccormick/overview/#References","page":"Overview","title":"References","text":"","category":"section"},{"location":"mccormick/overview/","page":"Overview","title":"Overview","text":"Khan KA, Watson HAJ, Barton PI (2017). Differentiable McCormick relaxations. Journal of Global Optimization, 67(4): 687-729.\nKhan KA, Wilhelm ME, Stuber MD, Cao H, Watson HAJ, Barton PI (2018). Corrections to: Differentiable McCormick relaxations. Journal of Global Optimization, 70(3): 705-706.\nKhan KA (2019). Whitney differentiability of optimal-value functions for bound-constrained convex programming problems. Optimization, 68(2-3): 691-711\nMitsos A, Chachuat B, and Barton PI. (2009). McCormick-based relaxations of algorithms. SIAM Journal on Optimization, 20(2): 573–601.\nNajman J, Bongratz D, Tsoukalas A, and Mitsos A (2017). Erratum to: Multivariate McCormick relaxations. Journal of Global Optimization, 68: 219-225.\nScott JK, Stuber MD, and Barton PI. (2011). Generalized McCormick relaxations. Journal of Global Optimization, 51(4): 569–606.\nStuber MD, Scott JK, Barton PI (2015). Convex and concave relaxations of implicit functions. Optim. Methods Softw., 30(3): 424–460\nTsoukalas A and Mitsos A (2014). Multivariate McCormick Relaxations. Journal of Global Optimization, 59: 633–662.\nWechsung A, Scott JK, Watson HAJ, and Barton PI. (2015). Reverse propagation of McCormick relaxations. Journal of Global Optimization, 63(1): 1-36.","category":"page"},{"location":"optimizer/optimizer/#EAGO-Optimizer","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"","category":"section"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"The Optimizer object holds all algorithm solution information. A description of all user-facing options has been provided in the docstring.","category":"page"},{"location":"optimizer/optimizer/#EAGO.Optimizer","page":"EAGO Optimizer","title":"EAGO.Optimizer","text":"","category":"section"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"Optimizer","category":"page"},{"location":"optimizer/optimizer/#EAGO.Optimizer","page":"EAGO Optimizer","title":"EAGO.Optimizer","text":"mutable struct Optimizer{Q, S, T} <: MathOptInterface.AbstractOptimizer\n\nThe 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:\n\nrelaxed_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}.\nupper_optimizer::MOI.AbstractOptimizer: Optimizer used to solve upper bounding problems (default = Ipopt.Optimizer()). Located in subsolver_block::SubSolvers{Q,S,T}.\next::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}.\nenable_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}.\nobbt_variable_values::Vector{Bool}: Variables to perform OBBT on (default: all variables in nonlinear expressions). Located in _global_optimizer::GlobalOptimizer{Q,S,T}.\n\nDescriptions of all Optimizer fields available in extended help.\n\nExtended Help\n\nsubsolver_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\nenable_optimize_hook::Bool: Specifies that the optimize_hook! function should be called rather than throw the problem to the standard routine\next::Union{Nothing, T} where T: (Deprecated, use subsolver_block instead) Storage for custom extension types\n_auxiliary_variable_info::Union{Nothing, EAGO._AuxVarData}: Information on any auxiliary variables\n_global_optimizer::GlobalOptimizer{Q, S, T} where {Q, S, T}: Additional options and temporary storage for solving optimization problems\n_input_problem::InputProblem: Expressions and constraints added to the EAGO model (not directly used for relaxations)\n_working_problem::ParsedProblem: Expressions and problem descriptions that EAGO uses to formulate relaxed problems\n_parameters::EAGOParameters: Parameters that do not change during a global solve\n_optimizer_attributes_set::Vector{MathOptInterface.AbstractOptimizerAttribute}: Set of optimizer attributes\n_termination_status_code::MathOptInterface.TerminationStatusCode: The MathOptInterface-compliant completion status code\n_result_status_code::MathOptInterface.ResultStatusCode: Value indicating the feasibility status of the result\n_run_time::Float64: Optimization run time\n_objective_value::Float64: The objective value of the primal solution\n_objective_bound::Float64: The best-known bound on the optimal objective value\n_relative_gap::Float64: The gap between the upper and lower bound, relative to the bound with the larger magnitude\n_iteration_count::Int64: The number of iterations the branch-and-bound algorithm has completed\n_node_count::Int64: The number of nodes in the stack\n\n\n\n\n\n","category":"type"},{"location":"optimizer/optimizer/#EAGO-Specific-Functions-and-Operators","page":"EAGO Optimizer","title":"EAGO Specific Functions and Operators","text":"","category":"section"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"EAGO supports a number of functions and operators that for which specialized relaxation routines are available. These can be registered and added to a JuMP model using the function:","category":"page"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"EAGO.register_eago_operators!(m::JuMP.Model)","category":"page"},{"location":"optimizer/optimizer/#EAGO.register_eago_operators!-Tuple{Model}","page":"EAGO Optimizer","title":"EAGO.register_eago_operators!","text":"registereagooperators!\n\nRegisters all nonstandard nonlinear terms available in EAGO in a JuMP. Uses of these is generally preferable in EAGO as the relaxations EAGO will generate will usually be tighter (speeding up convergence time). Note that this will work can be used by other nonlinear solvers (Ipopt for instance).\n\n\n\n\n\n","category":"method"},{"location":"optimizer/optimizer/#Storage-for-Input-Parameters","page":"EAGO Optimizer","title":"Storage for Input Parameters","text":"","category":"section"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"EAGO.EAGOParameters","category":"page"},{"location":"optimizer/optimizer/#EAGO.EAGOParameters","page":"EAGO Optimizer","title":"EAGO.EAGOParameters","text":"mutable struct EAGOParameters\n\nStorage for parameters that do not change during a global solve.\n\npresolve_scrubber_flag::Bool: Should EAGO attempt to remove type-assert issues for user-defined functions (default = false)\npresolve_to_JuMP_flag::Bool: Create and use DAG representations of user-defined functions (default = false)\npresolve_flatten_flag::Bool: Rerrange the DAG using registered transformations (default = false)\nconic_convert_quadratic::Bool: Attempt to bridge convex constraint to second-order cone (default = false)\nlog_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)\nlog_subproblem_info::Bool: Turn on logging of times and feasibility of subproblems (default = false)\nlog_interval::Int64: Log data every log_interval iterations (default = 1)\nverbosity::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)\noutput_iterations::Int64: Display summary of iteration to console every output_iterations (default = 1000)\nheader_iterations::Int64: Display header for summary to console every output_iterations (default = 100000)\nbranch_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)\nbranch_offset::Float64: Minimum distance from bound to have branch point, normalized by width of dimension to branch on (default = 0.15)\nbranch_pseudocost_on::Bool: Indicate that pseudocost branching should be used (default = false)\nbranch_variable::Vector{Bool}: Variables to branch on (default is all nonlinear)\nbranch_max_repetitions::Int64: [FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED] Number of times to repeat node processing prior to branching (default = 4)\nbranch_repetition_tol::Float64: [FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED] Volume ratio tolerance required to repeat processing the current node (default = 0.9)\nnode_limit::Int64: Maximum number of nodes (default = 1E7)\ntime_limit::Float64: Maximum CPU time in seconds (default = 3600)\niteration_limit::Int64: Maximum number of iterations (default 1E9)\nabsolute_tolerance::Float64: Absolute tolerance for termination (default = 1E-3)\nrelative_tolerance::Float64: Relative tolerance for termination (default = 1E-3)\nabsolute_constraint_feas_tolerance::Float64: Absolute constraint feasibility tolerance (default = 1E-8)\ncp_depth::Int64: Depth in B&B tree above which constraint propagation should be disabled (default = 0)\ncp_repetitions::Int64: Number of times to repeat forward-reverse pass routine (default = 0)\ncp_tolerance::Float64: Disable constraint propagation if the ratio of new node volume to beginning node volume exceeds this number (default = 0.99)\ncp_interval_only::Bool: Use only valid interval bounds during constraint propagation (default = false)\nobbt_depth::Int64: Depth in B&B tree above which OBBT should be disabled (default = 6)\nobbt_repetitions::Int64: Number of repetitions of OBBT to perform in preprocessing (default = 3)\nobbt_aggressive_on::Bool: Turn on aggresive OBBT (default = true)\nobbt_aggressive_max_iteration::Int64: Maximum iteration to perform aggresive OBBT (default = 2)\nobbt_aggressive_min_dimension::Int64: Minimum dimension to perform aggresive OBBT (default = 2)\nobbt_tolerance::Float64: Tolerance to consider bounds equal (default = 1E-10)\nfbbt_lp_depth::Int64: Depth in B&B tree above which linear FBBT should be disabled (default = 1000)\nfbbt_lp_repetitions::Int64: Number of repetitions of linear FBBT to perform in preprocessing (default = 3)\ndbbt_depth::Int64: Depth in B&B tree above which duality-based bound tightening should be disabled (default = 1E10)\ndbbt_tolerance::Float64: New bound is considered equal to the prior bound if within dbbt_tolerance (default = 1E-8)\nrelax_tag::RelaxTag: RelaxTag used to specify type of McCormick operator (default = NS())\nsubgrad_tighten::Bool: Perform tightening of interval bounds using subgradients at each factor in each nonlinear tape during a forward pass (default = true)\nreverse_subgrad_tighten::Bool: Perform tightening of interval bounds using subgradients at each factor in each nonlinear tape during a reverse pass (default = false)\nsubgrad_tol::Float64: Outer-round computed subgradient bounds by this amount (default = 1E-10)\nmul_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)\ncut_min_iterations::Int64: Minimum number of cuts at each node to attempt (unsafe cuts not necessarily added) (default = 2)\ncut_max_iterations::Int64: Maximum number of cuts at each node to attempt (default = 8)\ncut_tolerance_abs::Float64: Absolute tolerance checked for continuing cut (default = 1E-6)\ncut_tolerance_rel::Float64: Relative tolerance checked for continuing cut (default = 1E-3)\ncut_safe_on::Bool: Use tolerances to determine safe cuts in a Khajavirad 2018 manner (default = true)\ncut_safe_l::Float64: Lower tolerance for safe-lp cut, Khajavirad 2018 (default = 1E-7)\ncut_safe_u::Float64: Upper tolerance for safe-lp cut, Khajavirad 2018 (default = 1E7)\ncut_safe_b::Float64: Constant tolerance for safe-lp cut, Khajavirad 2018 (default = 1E9)\nupper_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)\ndomain_violation_guard_on::Bool: (Unused) Protect against domain violation (default = false)\ndomain_violation_ϵ::Float64: (Unused) Amount about a domain violation to ignore when propagating bounds (default = 1E-9)\nuser_solver_config::Bool: If true, EAGO forgoes its default configuration process for subsolvers (default = false)\ninteger_abs_tol::Float64: Absolute tolerance used to check for integrality of decision variables (default = 1E-9)\ninteger_rel_tol::Float64: Relative tolerance used to check for integrality of decision variables (default = 1E-9)\nforce_global_solve::Bool: Ignore EAGO's ability to parse problem types and force it to run global optimization (default = false)\nunbounded_check::Bool: Check that all branching variables have finite bounds and set them to +/- 1E10 if not (default = true)\n\n\n\n\n\n","category":"type"},{"location":"optimizer/optimizer/#Internal-Storage-Structures","page":"EAGO Optimizer","title":"Internal Storage Structures","text":"","category":"section"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"VariableInfo\nExtensionType","category":"page"},{"location":"optimizer/optimizer/#EAGO.VariableInfo","page":"EAGO Optimizer","title":"EAGO.VariableInfo","text":"struct VariableInfo{T<:AbstractFloat}\n\nA structure used to store information related to the bounds assigned to each variable.\n\nis_integer::Bool: Is the variable integer valued?\nhas_lower_bound::Bool: Boolean indicating whether a finite lower bound exists.\nhas_upper_bound::Bool: Boolean indicating whether a finite upper bound exists.\nis_fixed::Bool: Boolean indicating if variable is fixed to a finite value.\nhas_constraints::Bool: Boolean indicating that constraints have been set\nlower_bound::AbstractFloat: Lower bound. May be -Inf.\nupper_bound::AbstractFloat: Upper bound. May be Inf.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/optimizer/#EAGO.ExtensionType","page":"EAGO Optimizer","title":"EAGO.ExtensionType","text":"abstract type ExtensionType\n\nAn 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.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/optimizer/#Internal-Problem-Representations","page":"EAGO Optimizer","title":"Internal Problem Representations","text":"","category":"section"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"EAGO.InputProblem\nEAGO.ParsedProblem","category":"page"},{"location":"optimizer/optimizer/#EAGO.InputProblem","page":"EAGO Optimizer","title":"EAGO.InputProblem","text":"mutable struct InputProblem\n\nA structure used to hold objectives and constraints added to the EAGO model. The constraints generally aren't used for relaxations.\n\nAll field information available in extended help.\n\nExtended Help\n\n_variable_count::Int64: Count for the number of variables\n_variable_names::Dict{MathOptInterface.VariableIndex, String}: Dictionary containing variable indices and their names\n_constraint_count::Int64: Count for the number of constraints\n_vi_leq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}}\n_vi_geq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}}\n_vi_eq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.EqualTo{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.EqualTo{Float64}}}\n_vi_it_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.Interval{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.Interval{Float64}}}\n_vi_zo_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.ZeroOne}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.ZeroOne}}\n_vi_int_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.Integer}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.Integer}}\n_linear_leq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, Tuple{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}}\n_linear_geq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Tuple{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}\n_linear_eq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Tuple{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}}\n_quadratic_leq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}, Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}}\n_quadratic_geq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}\n_quadratic_eq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}}\n_conic_second_order::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VectorOfVariables, MathOptInterface.SecondOrderCone}, Tuple{MathOptInterface.VectorOfVariables, MathOptInterface.SecondOrderCone}}\n_linear_leq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, Float64}\n_linear_geq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Float64}\n_linear_eq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Float64}\n_quadratic_leq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}, Float64}\n_quadratic_geq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Float64}\n_quadratic_eq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Float64}\n_linear_leq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}}\n_linear_geq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}\n_linear_eq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}}\n_quadratic_leq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}}\n_quadratic_geq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}\n_quadratic_eq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}}\n_objective::Union{Nothing, MathOptInterface.VariableIndex, MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.ScalarQuadraticFunction{Float64}}: Storage for the objective function\n_nlp_data::Union{Nothing, MathOptInterface.NLPBlockData}: Storage for NLP constraints (set by MOI.set(m, ::NLPBlockData...) in moi_wrapper.jl)\n_optimization_sense::MathOptInterface.OptimizationSense: Objective sense information (set by MOI.set(m, ::ObjectiveSense...))\n\n\n\n\n\n","category":"type"},{"location":"optimizer/optimizer/#EAGO.ParsedProblem","page":"EAGO Optimizer","title":"EAGO.ParsedProblem","text":"mutable struct ParsedProblem\n\nA structure used to store expressions and problem descriptions EAGO uses to formulate relaxed problems.\n\nAll field information available in extended help.\n\nExtended Help\n\n_problem_type::Union{Nothing, EAGO.DIFF_CVX, EAGO.LP, EAGO.MILP, EAGO.MINCVX, EAGO.MISOCP, EAGO.SOCP}: Problem classification (set in parse_classify_problem!)\n_objective_saf::MathOptInterface.ScalarAffineFunction{Float64}: Stores the objective and is used for constructing linear affine cuts\n_objective::Union{Nothing, MathOptInterface.VariableIndex, EAGO.AffineFunctionIneq, EAGO.BufferedQuadraticIneq, EAGO.BufferedNonlinearFunction}: Storage for the objective function\n_optimization_sense::MathOptInterface.OptimizationSense: Objective sense information (set by MOI.set(m, ::ObjectiveSense...))\n_saf_leq::Vector{EAGO.AffineFunctionIneq}\n_saf_eq::Vector{EAGO.AffineFunctionEq}\n_sqf_leq::Vector{EAGO.BufferedQuadraticIneq}\n_sqf_eq::Vector{EAGO.BufferedQuadraticEq}\n_conic_second_order::Vector{EAGO.BufferedSOC}\n_nlp_data::Union{Nothing, MathOptInterface.NLPBlockData}\n_nonlinear_constr::Vector{EAGO.BufferedNonlinearFunction}\n_relaxed_evaluator::Evaluator\n_variable_info::Vector{VariableInfo{Float64}}: Variable information (set in initial_parse!)\n_variable_count::Int64: Count for the number of variables\n\n\n\n\n\n","category":"type"},{"location":"optimizer/optimizer/#Interval-Optimizer-Subroutines","page":"EAGO Optimizer","title":"Interval Optimizer Subroutines","text":"","category":"section"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"EAGO.initial_parse!(m::Optimizer{R,S,T}) where {R,S,T}","category":"page"},{"location":"optimizer/optimizer/#EAGO.initial_parse!-Union{Tuple{Optimizer{R, S, T}}, Tuple{T}, Tuple{S}, Tuple{R}} where {R, S, T}","page":"EAGO Optimizer","title":"EAGO.initial_parse!","text":"initial_parse!(m::Optimizer{R, S, T})\n\n\nTranslate the input problem to the working problem. Any checks or optional manipulation are left to the presolve stage.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/optimizer/#Extending-EAGO","page":"EAGO Optimizer","title":"Extending EAGO","text":"","category":"section"},{"location":"optimizer/optimizer/","page":"EAGO Optimizer","title":"EAGO Optimizer","text":"Functionality has been included that allows for extensions to EAGO's Optimizer to be readily defined. This can be done in two ways first defining a new structure which is a subtype of ExtensionType and overloading methods associated with this new structure. An instance of this new structure is provided to the Optimizer using the ext_type keyword. This results in EAGO now dispatch to the new methods rather than the generally defined methods for the parent type. For a complete example, the reader is directed to the interval bounding example and the quasiconvex example. Alternatively, the user can overload the optimize_hook! for this subtype which will entirely circumvent the default global solution routine. Additional information can be stored in the ext field of the Optimizer. In order to allow for compatibility between packages the user is encouraged to append their extension name to the start of each variable name (e.g. newext_newdata).","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"","category":"page"},{"location":"jump/README/#EAGO-Easy-Advanced-Global-Optimization","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"","category":"section"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"EAGO is an open-source development environment for robust and global optimization in Julia. See the full README for more information.","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"PSOR Lab Current Version Build Status Documentation\n(Image: ) (Image: ) (Image: Build Status) (Image: codecov) (Image: )","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"EAGO is a deterministic global optimizer designed to address a wide variety of optimization problems, emphasizing nonlinear programs (NLPs), by propagating McCormick relaxations along the factorable structure of each expression in the NLP. Most operators supported by modern automatic differentiation (AD) packages are supported by EAGO and a number utilities for sanitizing native Julia code and generating relaxations on a wide variety of user-defined functions have been included. Currently, EAGO supports problems that have a priori variable bounds defined and have differentiable constraints. That is, problems should be specified in the generic form below:","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"beginaligned\nf^* = min_mathbf y in Y subset mathbb R^n_y f(mathbf y) \nrm st mathbf h(mathbf y) = mathbf 0 \n mathbf g(mathbf y) leq mathbf 0 \n Y = mathbf y^L mathbf y^U in mathbbIR^n \n qquad mathbf y^L mathbf y^U in mathbb R^n\nendaligned","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"For each nonlinear term, EAGO makes use of factorable representations to construct bounds and relaxations.","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"For example, given the function","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"f(x) = x (x - 5) sin(x)","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"a list is generated and rules for constructing McCormick relaxations are used to formulate relaxations in the original decision space, X [1]:","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"beginaligned\nv_1 = x \nv_2 = v_1 - 5 \nv_3 = sin(v_1) \nv_4 = v_1 v_2 \nv_5 = v_4 v_3 \nf(x) = v_5 \nendaligned","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"

\n\n

","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"Either these original relaxations, differentiable McCormick relaxations [2], or affine relaxations thereof can be used to construct relaxations of optimization problems useful in branch and bound routines for global optimization. Utilities are included to combine these with algorithms for relaxing implicit functions [3] and forward-reverse propagation of McCormick arithmetic [4].","category":"page"},{"location":"jump/README/#License","page":"EAGO - Easy Advanced Global Optimization","title":"License","text":"","category":"section"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"EAGO is licensed under the MIT License.","category":"page"},{"location":"jump/README/#Installation","page":"EAGO - Easy Advanced Global Optimization","title":"Installation","text":"","category":"section"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"EAGO is a registered Julia package that can be installed using the Julia package manager:","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"import Pkg\nPkg.add(\"EAGO\")","category":"page"},{"location":"jump/README/#Use-with-JuMP","page":"EAGO - Easy Advanced Global Optimization","title":"Use with JuMP","text":"","category":"section"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"EAGO makes use of JuMP to improve the user's experience in setting up optimization models. Consider the \"process\" problem instance from [5]:","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"beginaligned\n max_mathbf x in X 0063 x_4 x_7 - 504 x_1 - 0035 x_2 - 10 x_3 - 336 x_2 \nrm st x_1 (112 + 013167 x_8 - 000667 x_8^2) + x_4 = 0 \n -0001 x_4 x_9 x_6 (98 - x_6) + x_3 = 0 \n -(1098 x_8 - 0038 x_8^2) - 0325 x_6 + x_7 = 0 \n -(x_2 + x_5) x_1 + x_8 = 0 \n -x_1 + 122 x_4 - x_5 = 0 \n x_9 + 0222 x_10 - 3582 = 0 \n -30 x_7 + x_10 + 1330 = 0 \n X = 10 2000 times 0 16000 times 0 120 times 0 5000 \n qquad times 0 2000 times 85 93 times 909 5 times 3 12 times 12 4 times 145 162\nendaligned","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"This model can be formulated in Julia as:","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"using JuMP\nimport EAGO\n# Build model using EAGO's optimizer\nmodel = Model(EAGO.Optimizer)\n# Define bounded variables\nxL = [10.0, 0.0, 0.0, 0.0, 0.0, 85.0, 90.0, 3.0, 1.2, 145.0]\nxU = [2000.0, 16000.0, 120.0, 5000.0, 2000.0, 93.0, 95.0, 12.0, 4.0, 162.0]\n@variable(model, xL[i] <= x[i=1:10] <= xU[i])\n# Define nonlinear constraints\n@NLconstraints(model, begin\n -x[1]*(1.12 + 0.13167*x[8] - 0.00667*(x[8])^2) + x[4] == 0.0\n -0.001*x[4]*x[9]*x[6]/(98.0 - x[6]) + x[3] == 0.0\n -(1.098*x[8] - 0.038*(x[8])^2) - 0.325*x[6] + x[7] == 57.425\n -(x[2] + x[5])/x[1] + x[8] == 0.0\nend)\n# Define linear constraints\n@constraints(model, begin\n -x[1] + 1.22*x[4] - x[5] == 0.0\n x[9] + 0.222*x[10] == 35.82\n -3.0*x[7] + x[10] == -133.0\nend)\n# Define nonlinear objective\n@NLobjective(\n model, \n Max,\n 0.063*x[4]*x[7] - 5.04*x[1] - 0.035*x[2] - 10*x[3] - 3.36*x[5],\n)\n# Solve the optimization problem\noptimize!(model)","category":"page"},{"location":"jump/README/#Documentation","page":"EAGO - Easy Advanced Global Optimization","title":"Documentation","text":"","category":"section"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"EAGO has numerous features: a solver accessible from JuMP/MathOptInterface (MOI), domain reduction routines, McCormick relaxations, and specialized nonconvex semi-infinite program solvers. A full description of all features can be found on the documentation website. ","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"A series of examples have been provided in the documentation and in the form of Jupyter Notebooks in the separate EAGO-notebooks repository.","category":"page"},{"location":"jump/README/#A-Cautionary-Note-on-Global-Optimization","page":"EAGO - Easy Advanced Global Optimization","title":"A Cautionary Note on Global Optimization","text":"","category":"section"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"As a global optimization platform, EAGO's solvers can be used to find solutions of general nonconvex problems with a guaranteed certificate of optimality. However, global solvers suffer from the curse of dimensionality and therefore their performance is outstripped by convex/local solvers.","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"For users interested in large-scale applications, be warned that problems generally larger than a few variables may prove challenging for certain types of global optimization problems.","category":"page"},{"location":"jump/README/#Citing-EAGO","page":"EAGO - Easy Advanced Global Optimization","title":"Citing EAGO","text":"","category":"section"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"Please cite the following paper when using EAGO. In plain text form this is:","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"Wilhelm, M.E. and Stuber, M.D. EAGO.jl: easy advanced global optimization in Julia.\nOptimization Methods and Software. 37(2): 425-450 (2022). DOI: 10.1080/10556788.2020.1786566","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"As a BibTeX entry:","category":"page"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"@article{doi:10.1080/10556788.2020.1786566,\n author = {Wilhelm, M.E. and Stuber, M.D.},\n title = {EAGO.jl: easy advanced global optimization in Julia},\n journal = {Optimization Methods and Software},\n volume = {37},\n number = {2},\n pages = {425-450},\n year = {2022},\n publisher = {Taylor & Francis},\n doi = {10.1080/10556788.2020.1786566},\n URL = {https://doi.org/10.1080/10556788.2020.1786566},\n eprint = {https://doi.org/10.1080/10556788.2020.1786566}\n}","category":"page"},{"location":"jump/README/#References","page":"EAGO - Easy Advanced Global Optimization","title":"References","text":"","category":"section"},{"location":"jump/README/","page":"EAGO - Easy Advanced Global Optimization","title":"EAGO - Easy Advanced Global Optimization","text":"Mitsos, A., Chachuat, B., and Barton, P.I. McCormick-based relaxations of algorithms. SIAM Journal on Optimization. 20(2): 573–601 (2009).\nKhan, K.A., Watson, H.A.J., and Barton, P.I. Differentiable McCormick relaxations. Journal of Global Optimization. 67(4): 687–729 (2017).\nStuber, M.D., Scott, J.K., and Barton, P.I.: Convex and concave relaxations of implicit functions. Optimization Methods and Software 30(3): 424–460 (2015).\nWechsung, A., Scott, J.K., Watson, H.A.J., and Barton, P.I. Reverse propagation of McCormick relaxations. Journal of Global Optimization 63(1): 1–36 (2015).\nBracken, J., and McCormick, G.P. Selected Applications of Nonlinear Programming. John Wiley and Sons, New York (1968).","category":"page"},{"location":"optimizer/udf_utilities/#User-Defined-Functions-and-Directed-Acyclic-Graph-Utilities","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"User-Defined Functions and Directed Acyclic Graph Utilities","text":"","category":"section"},{"location":"optimizer/udf_utilities/","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"User-Defined Functions and Directed Acyclic Graph Utilities","text":"EAGO has included basic functionality to manipulate user-defined functions (UDFs). EAGO also has utilities for directed acyclic graphs (DAGs). These features are largely experimental and we're interested in providing additional features for novel use cases.","category":"page"},{"location":"optimizer/udf_utilities/#DAG-Substitution-and-Flattening","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"DAG Substitution and Flattening","text":"","category":"section"},{"location":"optimizer/udf_utilities/","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"User-Defined Functions and Directed Acyclic Graph Utilities","text":"dag_flattening!\nflatten_expression!\nregister_substitution!\nTemplate_Graph\nTemplate_Node","category":"page"},{"location":"optimizer/udf_utilities/#EAGO.Script.dag_flattening!","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"EAGO.Script.dag_flattening!","text":"dag_flattening!\n\nFlattens (usually) the dag by making all registered substitutions for every nonlinear term in the Optimizer.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/udf_utilities/#EAGO.Script.flatten_expression!","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"EAGO.Script.flatten_expression!","text":"flatten_expression!\n\nFlattens (usually) the dag by making all registered substitutions for the expression expr::MOINL.Expression. Performs a depth-first search through the expression adding the terminal node to the stack, then checking to determine if it matches a registered substitution pattern. If it doesn't not then node is added to the new expression graph representation and it's children are added to the queue. If an expression (node) is identified as a pattern then it is substituted and any children expression nodes are then checked for patterns until the depth first search is exhausted.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/udf_utilities/#EAGO.Script.register_substitution!","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"EAGO.Script.register_substitution!","text":"register_substitution!\n\nSpecifies that the src::Template_Graph should be subsituted out for the trg::Template_Graph.\n\nConventions for substition, the expression to be checked always appears at key 1 in the Template_Graph and operations are ordered from low value to high value left to right so if 1 is a -, and 4 => 1, 3 => 1 then the expression is 4 - 3\n\n\n\n\n\n","category":"function"},{"location":"optimizer/udf_utilities/#EAGO.Script.Template_Graph","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"EAGO.Script.Template_Graph","text":"Template_Graph\n\nHolds a list of Template_Nodes, set of directed edges, lengths, an adjacency matrix and the number of children.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/udf_utilities/#EAGO.Script.Template_Node","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"EAGO.Script.Template_Node","text":"Template_Node\n\nA structure which holds a symbol indicating whether the node is an operator, a number, or an expression type, a value which identifies the function or symbol value, potentially a numeric value num_value, and a check that can be run to verify the node is correct check.\n\n\n\n\n\n","category":"type"},{"location":"optimizer/udf_utilities/#UDF-Scrubber","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"UDF Scrubber","text":"","category":"section"},{"location":"optimizer/udf_utilities/","page":"User-Defined Functions and Directed Acyclic Graph Utilities","title":"User-Defined Functions and Directed Acyclic Graph Utilities","text":"scrub\nscrub!","category":"page"},{"location":"dev/contributing/#How-to-Contribute-to-EAGO","page":"Contributing","title":"How to Contribute to EAGO","text":"","category":"section"},{"location":"dev/contributing/","page":"Contributing","title":"Contributing","text":"We're always happy to welcome work with additional collaborators and contributors. One of the easy ways for newcomers to contribute is by adding additional McCormick relaxations.","category":"page"},{"location":"dev/contributing/","page":"Contributing","title":"Contributing","text":"If you have any requests for additional functionality, bug fixes, or comments, please feel free to open a new issue using the GitHub issue tracker or reach out to us.","category":"page"},{"location":"dev/contributing/#Contact-Us","page":"Contributing","title":"Contact Us","text":"","category":"section"},{"location":"dev/contributing/","page":"Contributing","title":"Contributing","text":"Please direct technical issues and/or bugs to the active developers: ","category":"page"},{"location":"dev/contributing/","page":"Contributing","title":"Contributing","text":"Robert Gottlieb\nDimitri Alston","category":"page"},{"location":"dev/contributing/","page":"Contributing","title":"Contributing","text":"All other questions should be directed to Prof. Stuber.","category":"page"},{"location":"mccormick/implicit/#Relaxation-of-Implicit-Functions","page":"Relaxation of Implicit Functions","title":"Relaxation of Implicit Functions","text":"","category":"section"},{"location":"mccormick/implicit/#High-Level-Functions","page":"Relaxation of Implicit Functions","title":"High-Level Functions","text":"","category":"section"},{"location":"mccormick/implicit/","page":"Relaxation of Implicit Functions","title":"Relaxation of Implicit Functions","text":"implicit_relax_h!","category":"page"},{"location":"mccormick/implicit/#McCormick.implicit_relax_h!","page":"Relaxation of Implicit Functions","title":"McCormick.implicit_relax_h!","text":"implicit_relax_h!(d)\nimplicit_relax_h!(d, interval_bnds)\n\n\nCompute relaxations of x(p) defined by h(x,p) = 0 where h is specifed as h(out, x, p).\n\n\n\n\n\n","category":"function"},{"location":"mccormick/implicit/#Data-Structures","page":"Relaxation of Implicit Functions","title":"Data Structures","text":"","category":"section"},{"location":"mccormick/implicit/","page":"Relaxation of Implicit Functions","title":"Relaxation of Implicit Functions","text":"McCormick.AbstractContractorMC\nNewtonGS\nKrawczykCW\nMcCormick.AbstractPreconditionerMC\nDenseMidInv\nMcCormick.AbstractMCCallback\nMCCallback","category":"page"},{"location":"mccormick/implicit/#McCormick.AbstractContractorMC","page":"Relaxation of Implicit Functions","title":"McCormick.AbstractContractorMC","text":"abstract type AbstractContractorMC\n\nAn abstract type for each manner of contractor using in the implicit function relaxation algorithms.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/implicit/#McCormick.NewtonGS","page":"Relaxation of Implicit Functions","title":"McCormick.NewtonGS","text":"struct NewtonGS <: McCormick.AbstractContractorMC\n\nThe Gauss-Seidel implementation of the Newton contractor used in the implicit relaxation scheme.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/implicit/#McCormick.KrawczykCW","page":"Relaxation of Implicit Functions","title":"McCormick.KrawczykCW","text":"struct KrawczykCW <: McCormick.AbstractContractorMC\n\nThe componentwise implementation of the Krawczyk contractor used in the implicit relaxation scheme.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/implicit/#McCormick.AbstractPreconditionerMC","page":"Relaxation of Implicit Functions","title":"McCormick.AbstractPreconditionerMC","text":"abstract type AbstractPreconditionerMC\n\nAn abstract type for each manner of preconditioner used in the implicit function relaxation algorithms.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/implicit/#McCormick.DenseMidInv","page":"Relaxation of Implicit Functions","title":"McCormick.DenseMidInv","text":"struct DenseMidInv{S<:VecOrMat{Float64}} <: McCormick.AbstractPreconditionerMC\n\nA dense LU preconditioner for implicit McCormick relaxation.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/implicit/#McCormick.AbstractMCCallback","page":"Relaxation of Implicit Functions","title":"McCormick.AbstractMCCallback","text":"abstract type AbstractMCCallback\n\nAn abstract type for each manner of callback functions used in the implicit function relaxation algorithms.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/implicit/#McCormick.MCCallback","page":"Relaxation of Implicit Functions","title":"McCormick.MCCallback","text":"mutable struct MCCallback{FH, FJ, C<:McCormick.AbstractContractorMC, PRE<:McCormick.AbstractPreconditionerMC, N, T<:RelaxTag, AMAT<:(AbstractMatrix)} <: AbstractMCCallback\n\nA structure used to compute implicit relaxations.\n\nh!::Any: Function h(x,p) = 0 defined in place by h!(out,x,p)\nhj!::Any: Jacobian of h(x,p) w.r.t x\nH::Array{MC{N, T}, 1} where {N, T<:RelaxTag}: Intermediate inplace storage for output of h!\nJ::AbstractMatrix: Intermediate inplace storage for output of hj!\nJ0::Vector{AMAT} where AMAT<:(AbstractMatrix)\nxz0::Vector{AMAT} where AMAT<:(AbstractMatrix)\nxmid::Vector{Float64}\nX::Vector{Interval{Float64}}: State space x interval bounds\nP::Vector{Interval{Float64}}: Decision space p interval bounds\nnx::Int64: State space dimension\nnp::Int64: Decision space dimension\nλ::Float64: Convex combination parameter\neps::Float64: Tolerance for interval equality\nkmax::Int64: Number of contractor steps to take\npref_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}: Reference decision point at which affine relaxations are calculated (and used in subsequent calculations).\np_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}: Decision point at which relaxation is evaluated.\np_temp_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}: Vector used to temporarily store p in genexpansionparams! routine.\nx0_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}\nx_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}\nxa_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}\nxA_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}\naff_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}\nz_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}\ncontractor::McCormick.AbstractContractorMC: Type of contractor used in implicit relaxation routine.\npreconditioner::McCormick.AbstractPreconditionerMC: Preconditioner used in the implicit relaxation routine.\napply_precond::Bool: Boolean indicating that the preconditioner should be applied\nparam::Array{Array{MC{N, T}, 1}, 1} where {N, T<:RelaxTag}: Vector of relaxations of x at each iteration used to generated affine relaxations used in intermediate calculation.\nuse_apriori::Bool: Indicates that subgradient-based apriori relaxations of multiplication should be used.\n\n\n\n\n\n","category":"type"},{"location":"mccormick/implicit/#Subroutines","page":"Relaxation of Implicit Functions","title":"Subroutines","text":"","category":"section"},{"location":"mccormick/implicit/","page":"Relaxation of Implicit Functions","title":"Relaxation of Implicit Functions","text":"preconditioner_storage\naffine_exp!\ncorrect_exp!\ncontract!\nprecond_and_contract!\nfinal_cut\ngen_expansion_params!\npopulate_affine!","category":"page"},{"location":"mccormick/implicit/#McCormick.preconditioner_storage","page":"Relaxation of Implicit Functions","title":"McCormick.preconditioner_storage","text":"preconditioner_storage(x, t)\n\n\nCreates storage corresponding to x::AbstractPreconditionerMC and t::T where T<:RelaxTag.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/implicit/#McCormick.affine_exp!","page":"Relaxation of Implicit Functions","title":"McCormick.affine_exp!","text":"affine_exp!(x, p, d)\n\n\nComputates the affine relaxations of the state variable.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/implicit/#McCormick.correct_exp!","page":"Relaxation of Implicit Functions","title":"McCormick.correct_exp!","text":"correct_exp!(d)\n\n\nCorrects the relaxation of the state variable x_mc if the affine relaxation,\n\n\n\n\n\n","category":"function"},{"location":"mccormick/implicit/#McCormick.contract!","page":"Relaxation of Implicit Functions","title":"McCormick.contract!","text":"Performs a single step of the parametric method associated with t assumes that the inputs have been preconditioned.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/implicit/#McCormick.precond_and_contract!","page":"Relaxation of Implicit Functions","title":"McCormick.precond_and_contract!","text":"precond_and_contract!(d!, k, b)\n\n\n\n\n\n\n","category":"function"},{"location":"mccormick/implicit/#McCormick.final_cut","page":"Relaxation of Implicit Functions","title":"McCormick.final_cut","text":"final_cut(x, y)\n\n\nAn operator that cuts the x object using the y bounds in a differentiable or nonsmooth fashion to achieve a composite relaxation within y.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/implicit/#McCormick.gen_expansion_params!","page":"Relaxation of Implicit Functions","title":"McCormick.gen_expansion_params!","text":"gen_expansion_params!(d)\ngen_expansion_params!(d, interval_bnds)\n\n\nConstructs parameters need to compute relaxations of h.\n\n\n\n\n\n","category":"function"},{"location":"mccormick/implicit/#McCormick.populate_affine!","page":"Relaxation of Implicit Functions","title":"McCormick.populate_affine!","text":"populate_affine!(d, interval_bnds)\n\n\nPopulates x_mc, xa_mc, xA_mc, and z_mc with affine bounds.\n\n\n\n\n\n","category":"function"},{"location":"dev/api_types/#Types","page":"Types","title":"Types","text":"","category":"section"},{"location":"dev/api_types/","page":"Types","title":"Types","text":"Modules = [EAGO]\nOrder = [:type]","category":"page"},{"location":"dev/api_types/#EAGO.AbstractCache-dev-api_types","page":"Types","title":"EAGO.AbstractCache","text":"abstract type AbstractCache\n\nAbstract supertype used for information storage object the directed acyclic graph.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.AbstractCacheAttribute-dev-api_types","page":"Types","title":"EAGO.AbstractCacheAttribute","text":"abstract type AbstractCacheAttribute\n\nAbstract supertype used for attributes stored in a cache.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.AbstractDirectedGraph-dev-api_types","page":"Types","title":"EAGO.AbstractDirectedGraph","text":"abstract type AbstractDirectedGraph\n\nAbstract supertype for generic directed graph structure.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.AbstractEAGOConstraint-dev-api_types","page":"Types","title":"EAGO.AbstractEAGOConstraint","text":"abstract type AbstractEAGOConstraint\n\nAn abstract super-type used for representing constraints built by EAGO's backend.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.AffineFunctionEq-dev-api_types","page":"Types","title":"EAGO.AffineFunctionEq","text":"mutable struct AffineFunctionEq <: EAGO.AbstractEAGOConstraint\n\nRepresentation of an affine equality. Currently only used for bound tightening.\n\nterms::Vector{Tuple{Float64, Int64}}\nconstant::Float64\nlen::Int64\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.AffineFunctionIneq-dev-api_types","page":"Types","title":"EAGO.AffineFunctionIneq","text":"mutable struct AffineFunctionIneq <: EAGO.AbstractEAGOConstraint\n\nRepresentation of an affine inequality. Currently only used for bound tightening.\n\nterms::Vector{Tuple{Float64, Int64}}\nconstant::Float64\nlen::Int64\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.AtomType-dev-api_types","page":"Types","title":"EAGO.AtomType","text":"AtomType\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.BufferedNonlinearFunction-dev-api_types","page":"Types","title":"EAGO.BufferedNonlinearFunction","text":"mutable struct BufferedNonlinearFunction{V, N, T<:RelaxTag} <: EAGO.AbstractEAGOConstraint\n\nStores a general nonlinear function with a buffer represented by the sum of a tape and a scalar affine function.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.BufferedQuadraticEq-dev-api_types","page":"Types","title":"EAGO.BufferedQuadraticEq","text":"mutable struct BufferedQuadraticEq <: EAGO.AbstractEAGOConstraint\n\nRepresentation of a general quadratic equality constraint with a buffer.\n\nfunc::MathOptInterface.ScalarQuadraticFunction{Float64}\nminus_func::MathOptInterface.ScalarQuadraticFunction{Float64}\nbuffer::Dict{Int64, Float64}\nsaf::MathOptInterface.ScalarAffineFunction{Float64}\nlen::Int64\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.BufferedQuadraticIneq-dev-api_types","page":"Types","title":"EAGO.BufferedQuadraticIneq","text":"mutable struct BufferedQuadraticIneq <: EAGO.AbstractEAGOConstraint\n\nRepresentation of a general quadratic inequality constraint with a buffer.\n\nfunc::MathOptInterface.ScalarQuadraticFunction{Float64}\nbuffer::Dict{Int64, Float64}\nsaf::MathOptInterface.ScalarAffineFunction{Float64}\nlen::Int64\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.BufferedSOC-dev-api_types","page":"Types","title":"EAGO.BufferedSOC","text":"mutable struct BufferedSOC <: EAGO.AbstractEAGOConstraint\n\nRepresentation of a second-order cone with a buffer.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.DirectedTree-dev-api_types","page":"Types","title":"EAGO.DirectedTree","text":"DirectedTree\n\nA tree graph with a single sink node.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.EAGOParameters-dev-api_types","page":"Types","title":"EAGO.EAGOParameters","text":"mutable struct EAGOParameters\n\nStorage for parameters that do not change during a global solve.\n\npresolve_scrubber_flag::Bool: Should EAGO attempt to remove type-assert issues for user-defined functions (default = false)\npresolve_to_JuMP_flag::Bool: Create and use DAG representations of user-defined functions (default = false)\npresolve_flatten_flag::Bool: Rerrange the DAG using registered transformations (default = false)\nconic_convert_quadratic::Bool: Attempt to bridge convex constraint to second-order cone (default = false)\nlog_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)\nlog_subproblem_info::Bool: Turn on logging of times and feasibility of subproblems (default = false)\nlog_interval::Int64: Log data every log_interval iterations (default = 1)\nverbosity::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)\noutput_iterations::Int64: Display summary of iteration to console every output_iterations (default = 1000)\nheader_iterations::Int64: Display header for summary to console every output_iterations (default = 100000)\nbranch_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)\nbranch_offset::Float64: Minimum distance from bound to have branch point, normalized by width of dimension to branch on (default = 0.15)\nbranch_pseudocost_on::Bool: Indicate that pseudocost branching should be used (default = false)\nbranch_variable::Vector{Bool}: Variables to branch on (default is all nonlinear)\nbranch_max_repetitions::Int64: [FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED] Number of times to repeat node processing prior to branching (default = 4)\nbranch_repetition_tol::Float64: [FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED] Volume ratio tolerance required to repeat processing the current node (default = 0.9)\nnode_limit::Int64: Maximum number of nodes (default = 1E7)\ntime_limit::Float64: Maximum CPU time in seconds (default = 3600)\niteration_limit::Int64: Maximum number of iterations (default 1E9)\nabsolute_tolerance::Float64: Absolute tolerance for termination (default = 1E-3)\nrelative_tolerance::Float64: Relative tolerance for termination (default = 1E-3)\nabsolute_constraint_feas_tolerance::Float64: Absolute constraint feasibility tolerance (default = 1E-8)\ncp_depth::Int64: Depth in B&B tree above which constraint propagation should be disabled (default = 0)\ncp_repetitions::Int64: Number of times to repeat forward-reverse pass routine (default = 0)\ncp_tolerance::Float64: Disable constraint propagation if the ratio of new node volume to beginning node volume exceeds this number (default = 0.99)\ncp_interval_only::Bool: Use only valid interval bounds during constraint propagation (default = false)\nobbt_depth::Int64: Depth in B&B tree above which OBBT should be disabled (default = 6)\nobbt_repetitions::Int64: Number of repetitions of OBBT to perform in preprocessing (default = 3)\nobbt_aggressive_on::Bool: Turn on aggresive OBBT (default = true)\nobbt_aggressive_max_iteration::Int64: Maximum iteration to perform aggresive OBBT (default = 2)\nobbt_aggressive_min_dimension::Int64: Minimum dimension to perform aggresive OBBT (default = 2)\nobbt_tolerance::Float64: Tolerance to consider bounds equal (default = 1E-10)\nfbbt_lp_depth::Int64: Depth in B&B tree above which linear FBBT should be disabled (default = 1000)\nfbbt_lp_repetitions::Int64: Number of repetitions of linear FBBT to perform in preprocessing (default = 3)\ndbbt_depth::Int64: Depth in B&B tree above which duality-based bound tightening should be disabled (default = 1E10)\ndbbt_tolerance::Float64: New bound is considered equal to the prior bound if within dbbt_tolerance (default = 1E-8)\nrelax_tag::RelaxTag: RelaxTag used to specify type of McCormick operator (default = NS())\nsubgrad_tighten::Bool: Perform tightening of interval bounds using subgradients at each factor in each nonlinear tape during a forward pass (default = true)\nreverse_subgrad_tighten::Bool: Perform tightening of interval bounds using subgradients at each factor in each nonlinear tape during a reverse pass (default = false)\nsubgrad_tol::Float64: Outer-round computed subgradient bounds by this amount (default = 1E-10)\nmul_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)\ncut_min_iterations::Int64: Minimum number of cuts at each node to attempt (unsafe cuts not necessarily added) (default = 2)\ncut_max_iterations::Int64: Maximum number of cuts at each node to attempt (default = 8)\ncut_tolerance_abs::Float64: Absolute tolerance checked for continuing cut (default = 1E-6)\ncut_tolerance_rel::Float64: Relative tolerance checked for continuing cut (default = 1E-3)\ncut_safe_on::Bool: Use tolerances to determine safe cuts in a Khajavirad 2018 manner (default = true)\ncut_safe_l::Float64: Lower tolerance for safe-lp cut, Khajavirad 2018 (default = 1E-7)\ncut_safe_u::Float64: Upper tolerance for safe-lp cut, Khajavirad 2018 (default = 1E7)\ncut_safe_b::Float64: Constant tolerance for safe-lp cut, Khajavirad 2018 (default = 1E9)\nupper_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)\ndomain_violation_guard_on::Bool: (Unused) Protect against domain violation (default = false)\ndomain_violation_ϵ::Float64: (Unused) Amount about a domain violation to ignore when propagating bounds (default = 1E-9)\nuser_solver_config::Bool: If true, EAGO forgoes its default configuration process for subsolvers (default = false)\ninteger_abs_tol::Float64: Absolute tolerance used to check for integrality of decision variables (default = 1E-9)\ninteger_rel_tol::Float64: Relative tolerance used to check for integrality of decision variables (default = 1E-9)\nforce_global_solve::Bool: Ignore EAGO's ability to parse problem types and force it to run global optimization (default = false)\nunbounded_check::Bool: Check that all branching variables have finite bounds and set them to +/- 1E10 if not (default = true)\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.Evaluator-dev-api_types","page":"Types","title":"EAGO.Evaluator","text":"Evaluator\n\nMOI.AbstractNLPEvaluator for calculating relaxations of nonlinear terms.\n\nChecks that the resulting value should be a number.\n\nuser_operators::EAGO.OperatorRegistry\nhas_user_mv_operator::Bool\nnum_mv_buffer::Vector{Float64}\nparameter_values::Vector{Float64}\nnode::NodeBB\nvariable_values::EAGO.VariableValues{Float64}\nsubgrad_tighten::Bool\nreverse_subgrad_tighten::Bool\nsubexpressions::Vector{EAGO.NonlinearExpression}\nsubexpressions_eval::Vector{Bool}\nis_post::Bool\nis_intersect::Bool\nis_first_eval::Bool\ninterval_intersect::Bool\nsubgrad_tol::Float64\nrelax_type::EAGO.RelaxType\npass_number::Int64\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.ExtensionType-dev-api_types","page":"Types","title":"EAGO.ExtensionType","text":"abstract type ExtensionType\n\nAn 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.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.GlobalEndState-dev-api_types","page":"Types","title":"EAGO.GlobalEndState","text":"primitive type GlobalEndState <: Enum{Int32} 32\n\nAn 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.\n\nIf no call has been made to optimize!, the GlobalEndState value is:\n\nGS_UNSET: The optimization algorithm has not stated.\n\nOK\n\nGS_OPTIMAL: A globally optimal solution was found.\nGS_INFEASIBLE: The algorithm concluded that no feasible solution exists.\n\nLimits reached\n\nGS_NODE_LIMIT: The branch-and-bound algorithm stopped because it reached the user-set maximum number of nodes in the branch-and-bound tree.\nGS_ITERATION_LIMIT: The maximum number of iterations was reached.\nGS_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.\nGS_ABSOLUTE_TOL: The gap between the lower and upper bounds is within the user-set absolute tolerance.\nGS_TIME_LIMIT: The algorithm stopped after the user-specified time limit was reached.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.GlobalOptimizer-dev-api_types","page":"Types","title":"EAGO.GlobalOptimizer","text":"mutable struct GlobalOptimizer{Q, S, T<:ExtensionType} <: MathOptInterface.AbstractOptimizer\n\nOptimizer internal to EAGO which holds information used to perform branch-and-bound in order to solve nonconvex MINLPs.\n\nDescriptions of all fields available in extended help.\n\nExtended Help\n\n_subsolvers::SubSolvers{Q, S} where {Q, S}: Storage for relaxed and upper optimizers to use, and any custom extensions\n_parameters::EAGOParameters: Parameters that do not change during a global solve\n_input_problem::InputProblem: Expressions and constraints added to the EAGO model (not directly used for relaxations)\n_working_problem::ParsedProblem: Expressions and problem descriptions that EAGO uses to formulate relaxed problems\n_auxiliary_variable_info::Union{Nothing, EAGO._AuxVarData}: Information on any auxiliary variables\nobbt_variable_values::Vector{Bool}: Variables to perform OBBT on (default: all variables in nonlinear expressions)\nenable_optimize_hook::Bool: Specifies that the optimize_hook! function should be called rather than throw the problem to the standard routine\next::Any: (Deprecated, use _subsolvers instead) Storage for custom extension types\n_end_state::EAGO.GlobalEndState: The completion status code for the branch-and-bound algorithm\n_termination_status_code::MathOptInterface.TerminationStatusCode: The MathOptInterface-compliant completion status code\n_result_status_code::MathOptInterface.ResultStatusCode: Value indicating the feasibility status of the result\n_obj_mult::Float64: Multiplier used internally to convert objective sense from Max to Min. Only takes on values of {-1.0, 1.0}\n_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!)\n_stack::DataStructures.BinaryMinMaxHeap{NodeBB}: A heap of all nodes in the branch-and-bound tree\n_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\n_first_relax_point_set::Bool: (Unused) Flag for relaxation points\n_current_xref::Vector{Float64}: (Unused) Variable values of a particular point\n_candidate_xref::Vector{Float64}: (Unused) Variable values of a candidate point\n_use_prior_objective_xref::Bool: (Unused) Flag to use variable values from previous evaluation on the current step\n_current_objective_xref::Vector{Float64}: (Unused) Variable values for objective evaluation\n_prior_objective_xref::Vector{Float64}: (Unused) Variable values for previous objective evaluation\n_user_branch_variables::Bool: Flag for if the user has specified branch variables (see label_branch_variables!)\n_fixed_variable::Vector{Bool}: Variables that are fixed in place\n_branch_variable_count::Int64: Number of variables that can be branched on\n_branch_to_sol_map::Vector{Int64}: Mapping from the branch variables to the full set of variables in the problem\n_sol_to_branch_map::Vector{Int64}: Mapping from the full set of variables in the problem to the branch variables\n_continuous_solution::Vector{Float64}: The final (or intermediate) variable values of the solution\n_preprocess_feasibility::Bool: Flag to ensure preprocessing result is feasible\n_preprocess_termination_status::MathOptInterface.TerminationStatusCode: Status codes for use in bounds tightening\n_preprocess_primal_status::MathOptInterface.ResultStatusCode: Status codes for use in bounds tightening\n_preprocess_dual_status::MathOptInterface.ResultStatusCode: Status codes for use in bounds tightening\n_lower_primal_status::MathOptInterface.ResultStatusCode: Primal status of the lower problem\n_lower_dual_status::MathOptInterface.ResultStatusCode: Dual status of the lower problem\n_lower_termination_status::MathOptInterface.TerminationStatusCode: Termination status of the lower problem\n_lower_feasibility::Bool: Flag for lower problem feasibility\n_lower_objective_value::Float64: Objective value result from the lower problem\n_lower_solution::Vector{Float64}: Variable values of the lower problem solution\n_lower_lvd::Vector{Float64}: Lower variable duals for use in duality-based bound tightening\n_lower_uvd::Vector{Float64}: Upper variable duals for use in duality-based bound tightening\n_last_cut_objective::Float64: Objective value associated with the previous cut in the cutting planes algorithm\n_upper_result_status::MathOptInterface.ResultStatusCode: Primal status of the upper problem\n_upper_termination_status::MathOptInterface.TerminationStatusCode: Termination status of the upper problem\n_upper_feasibility::Bool: Flag for upper problem feasibility\n_upper_objective_value::Float64: Objective value result from the upper problem\n_upper_variables::Vector{MathOptInterface.VariableIndex}: \n_upper_solution::Vector{Float64}: \n_postprocess_feasibility::Bool: (Unused) Flag to ensure postprocessing result is feasible\n_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!\n_start_time::Float64: Storage for the time() when optimization began\n_run_time::Float64: Current run time, incremented using time()-_start_time\n_parse_time::Float64: A field to keep track of time spent on initial problem parsing\n_presolve_time::Float64: Used in optimize_nonconvex.jl to track how long the presolve step takes\n_last_preprocess_time::Float64: Updated each iteration to track the time of the preprocess step\n_last_lower_problem_time::Float64: Updated each iteration to track the time of the lower problem step\n_last_upper_problem_time::Float64: Updated each iteration to track the time of the upper problem step\n_last_postprocessing_time::Float64: Updated each iteration to track the time of the postprocess step\n_min_converged_value::Float64: A field to track convergence progress across iterations\n_global_lower_bound::Float64: The best-known lower bound\n_global_upper_bound::Float64: The best-known upper bound\n_maximum_node_id::Int64: The total number of nodes that have been created\n_iteration_count::Int64: The number of iterations the branch-and-bound algorithm has completed\n_node_count::Int64: The number of nodes in the stack\n_solution_value::Float64: (Unused) The best-known solution value\n_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\n_solution_node::Int64: The node ID of the best-known feasible upper problem solution (default = -1, if no feasible solution is found)\n_best_upper_value::Float64: The best-known upper bound\n_obbt_working_lower_index::Vector{Bool}: Indices of variables to perform OBBT on\n_obbt_working_upper_index::Vector{Bool}: Indices of variables to perform OBBT on\n_lower_indx_diff::Vector{Bool}: Tracker for changes in obbtworkinglowerindex across iterations\n_upper_indx_diff::Vector{Bool}: Tracker for changes in obbtworkingupperindex across iterations\n_old_low_index::Vector{Bool}: Storage for indices prior to OBBT step\n_old_upp_index::Vector{Bool}: Storage for indices prior to OBBT step\n_new_low_index::Vector{Bool}: New indices following OBBT step; compared with _old_low_index\n_new_upp_index::Vector{Bool}: New indices following OBBT step; compared with _old_upp_index\n_obbt_variables::Vector{MathOptInterface.VariableIndex}: (Deprecated) Variables to perform OBBT on. Replaced by _obbt_working_lower_index and _obbt_working_upper_index\n_obbt_variable_count::Int64: The number of variables to perform OBBT on\n_obbt_performed_flag::Bool: (Unused) Flag to indicate whether OBBT has been performed\n_lower_fbbt_buffer::Vector{Float64}: Buffer for FBBT lower bounds. Set in presolve, used in preprocess\n_upper_fbbt_buffer::Vector{Float64}: Buffer for FBBT upper bounds. Set in presolve, used in preprocess\n_cp_improvement::Float64: (Unused) Improvement in constraint propagation\n_cp_evaluation_reverse::Bool: (Unused) Flag for if constraint propagation results need to be reversed\n_cut_iterations::Int64: Iterations of the cutting planes algorithm completed\n_cut_add_flag::Bool: (Unused) Flag to check if cuts should be added\n_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\n_log::Log: Storage for logging information during a branch-and-bound run\n_affine_relax_ci::Vector{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}}: Storage for affine constraints\n_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\n_relaxed_variable_number::Int64: (Unused) Number of relaxed variables\n_relaxed_variable_index::Vector{MathOptInterface.VariableIndex}: Indices of relaxed variables\n_relaxed_variable_et::Vector{Tuple{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.EqualTo{Float64}}, Int64}}: Stored EqualTo constraints\n_relaxed_variable_lt::Vector{Tuple{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}, Int64}}: Stored LessThan constraints\n_relaxed_variable_gt::Vector{Tuple{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}, Int64}}: Stored GreaterThan constraints\n_relaxed_variable_integer::Vector{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.Integer}}: Stored Integer constraints\n_branch_variables::Vector{Bool}: List of variables that can be branched on. If not user-specified, branch variables are identified in label_branch_variables!\n_nonbranching_int::Bool: (Unused) Flag for non-branching integers\n_new_eval_constraint::Bool: Flag indicating if an initial evaluation of the constraints has occurred\n_new_eval_objective::Bool: Flag indicating if the objective expression was evaluated\n_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!\n_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!\n_nonlinear_evaluator_created::Bool: Flag to check for nonlinear evaluators. Set to true in add_nonlinear_evaluator!\n_branch_cost::EAGO.BranchCostStorage{Float64}: (FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED) Storage for pseudocost branching\n_branch_variable_sparsity::SparseArrays.SparseMatrixCSC{Bool, Int64}: (FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED) Sparsity information of the branch variables\n_constraint_infeasiblity::Vector{Float64}: (FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED) Information on the infeasibility of each constraint\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.Incremental-dev-api_types","page":"Types","title":"EAGO.Incremental","text":"mutable struct Incremental{S<:MathOptInterface.AbstractOptimizer} <: MathOptInterface.AbstractOptimizer\n\nA 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. \n\n(Deprecated) For Q = Val{true}, the subsolver supports incremental loading. For Q = Val{false}, the subsolver does not.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.InputProblem-dev-api_types","page":"Types","title":"EAGO.InputProblem","text":"mutable struct InputProblem\n\nA structure used to hold objectives and constraints added to the EAGO model. The constraints generally aren't used for relaxations.\n\nAll field information available in extended help.\n\nExtended Help\n\n_variable_count::Int64: Count for the number of variables\n_variable_names::Dict{MathOptInterface.VariableIndex, String}: Dictionary containing variable indices and their names\n_constraint_count::Int64: Count for the number of constraints\n_vi_leq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.LessThan{Float64}}}\n_vi_geq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.GreaterThan{Float64}}}\n_vi_eq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.EqualTo{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.EqualTo{Float64}}}\n_vi_it_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.Interval{Float64}}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.Interval{Float64}}}\n_vi_zo_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.ZeroOne}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.ZeroOne}}\n_vi_int_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VariableIndex, MathOptInterface.Integer}, Tuple{MathOptInterface.VariableIndex, MathOptInterface.Integer}}\n_linear_leq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, Tuple{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}}\n_linear_geq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Tuple{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}\n_linear_eq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Tuple{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}}\n_quadratic_leq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}, Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}}\n_quadratic_geq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}\n_quadratic_eq_constraints::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}}\n_conic_second_order::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.VectorOfVariables, MathOptInterface.SecondOrderCone}, Tuple{MathOptInterface.VectorOfVariables, MathOptInterface.SecondOrderCone}}\n_linear_leq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, Float64}\n_linear_geq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Float64}\n_linear_eq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Float64}\n_quadratic_leq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}, Float64}\n_quadratic_geq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, Float64}\n_quadratic_eq_primal::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}, Float64}\n_linear_leq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64}}}\n_linear_geq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}\n_linear_eq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.EqualTo{Float64}}}\n_quadratic_leq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64}}}\n_quadratic_geq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.GreaterThan{Float64}}}\n_quadratic_eq_prob_to_ip::Dict{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}}\n_objective::Union{Nothing, MathOptInterface.VariableIndex, MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.ScalarQuadraticFunction{Float64}}: Storage for the objective function\n_nlp_data::Union{Nothing, MathOptInterface.NLPBlockData}: Storage for NLP constraints (set by MOI.set(m, ::NLPBlockData...) in moi_wrapper.jl)\n_optimization_sense::MathOptInterface.OptimizationSense: Objective sense information (set by MOI.set(m, ::ObjectiveSense...))\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.LocalResultStatus-dev-api_types","page":"Types","title":"EAGO.LocalResultStatus","text":"LocalResultStatus\n\nStatus code used internally to determine how to interpret the results from the solution of a local problem solve.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.Log-dev-api_types","page":"Types","title":"EAGO.Log","text":"mutable struct Log\n\nA structure used to store information on the history of the solution procedure for generating convergence plots and other analyses.\n\ncurrent_lower_bound::Vector{Float64}: Storage for lower bound calculated for current node.\ncurrent_upper_bound::Vector{Float64}: Storage for upper bound calculated for current node.\npreprocessing_time::Vector{Float64}: Storage for preprocessing time of each iteration.\nlower_problem_time::Vector{Float64}: Storage for lower bounding time of each iteration.\nupper_problem_time::Vector{Float64}: Storage for upper bounding time of each iteration.\npostprocessing_time::Vector{Float64}: Storage for postprocessing time of each iteration.\npreprocessing_feas::Vector{Bool}: Storage for preprocessing feasibility of each iteration.\nlower_problem_feas::Vector{Bool}: Storage for lower bounding feasibility of each iteration.\nupper_problem_feas::Vector{Bool}: Storage for upper bounding feasibility of each iteration.\npostprocessing_feas::Vector{Bool}: Storage for postprocessing feasibility of each iteration.\nglobal_lower_bound::Vector{Float64}: Storage for best (global) lower bound at each iteration.\nglobal_upper_bound::Vector{Float64}: Storage for best (global) upper bound at each iteration.\nnode_count::Vector{Int64}: Number of nodes at each iteration.\nrun_time::Vector{Float64}: Run time at each iteration.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.Node-dev-api_types","page":"Types","title":"EAGO.Node","text":"struct Node <: EAGO.AbstractNode\n\nDescribes connectivity and expression represented by node.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.NodeBB-dev-api_types","page":"Types","title":"EAGO.NodeBB","text":"struct NodeBB\n\nStore information associated with each node in the branch-and-bound tree.\n\nlower_variable_bounds::Vector{Float64}: Lower bounds of variable box.\nupper_variable_bounds::Vector{Float64}: Upper bounds of variable box.\nis_integer::BitVector: Is dimension integer valued\ncontinuous::Bool: Are all dimensions continuous (or fixed)\nlower_bound::Float64: Lower bound of problem solution on nodeBB\nupper_bound::Float64: Upper bound of problem solution on nodeBB\ndepth::Int64: Depth of node in B&B tree.\ncont_depth::Int64: Depth of first parent in B&B tree that was continuously valued\nid::Int64: Unique ID for each node.\nbranch_direction::EAGO.BranchDirection: Whether last branch was negative or positive in direction\nlast_branch::Int64: Dimension of last branch\nbranch_extent::Float64: Extent of last branch (using for psuedocost calculation)\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.NodeClass-dev-api_types","page":"Types","title":"EAGO.NodeClass","text":"NodeType\n\nEach node in the directed graph can be classified into the following types\n\nVARIABLE: Denotes a decision variable.\nPARAMETER: An adjustable parameter value (not a decision variable).\nCONSTANT: A constant value\nEXPRESSION: Any other expression that isn't a subexpression\nSUBEXPRESSION: Any expression referencing a different graph representation.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.NonlinearExpression-dev-api_types","page":"Types","title":"EAGO.NonlinearExpression","text":"mutable struct NonlinearExpression{V, N, T<:RelaxTag} <: EAGO.AbstractEAGOConstraint\n\nStores a general quadratic function with a buffer.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.Optimizer-dev-api_types","page":"Types","title":"EAGO.Optimizer","text":"mutable struct Optimizer{Q, S, T} <: MathOptInterface.AbstractOptimizer\n\nThe 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:\n\nrelaxed_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}.\nupper_optimizer::MOI.AbstractOptimizer: Optimizer used to solve upper bounding problems (default = Ipopt.Optimizer()). Located in subsolver_block::SubSolvers{Q,S,T}.\next::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}.\nenable_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}.\nobbt_variable_values::Vector{Bool}: Variables to perform OBBT on (default: all variables in nonlinear expressions). Located in _global_optimizer::GlobalOptimizer{Q,S,T}.\n\nDescriptions of all Optimizer fields available in extended help.\n\nExtended Help\n\nsubsolver_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\nenable_optimize_hook::Bool: Specifies that the optimize_hook! function should be called rather than throw the problem to the standard routine\next::Union{Nothing, T} where T: (Deprecated, use subsolver_block instead) Storage for custom extension types\n_auxiliary_variable_info::Union{Nothing, EAGO._AuxVarData}: Information on any auxiliary variables\n_global_optimizer::GlobalOptimizer{Q, S, T} where {Q, S, T}: Additional options and temporary storage for solving optimization problems\n_input_problem::InputProblem: Expressions and constraints added to the EAGO model (not directly used for relaxations)\n_working_problem::ParsedProblem: Expressions and problem descriptions that EAGO uses to formulate relaxed problems\n_parameters::EAGOParameters: Parameters that do not change during a global solve\n_optimizer_attributes_set::Vector{MathOptInterface.AbstractOptimizerAttribute}: Set of optimizer attributes\n_termination_status_code::MathOptInterface.TerminationStatusCode: The MathOptInterface-compliant completion status code\n_result_status_code::MathOptInterface.ResultStatusCode: Value indicating the feasibility status of the result\n_run_time::Float64: Optimization run time\n_objective_value::Float64: The objective value of the primal solution\n_objective_bound::Float64: The best-known bound on the optimal objective value\n_relative_gap::Float64: The gap between the upper and lower bound, relative to the bound with the larger magnitude\n_iteration_count::Int64: The number of iterations the branch-and-bound algorithm has completed\n_node_count::Int64: The number of nodes in the stack\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.ParsedProblem-dev-api_types","page":"Types","title":"EAGO.ParsedProblem","text":"mutable struct ParsedProblem\n\nA structure used to store expressions and problem descriptions EAGO uses to formulate relaxed problems.\n\nAll field information available in extended help.\n\nExtended Help\n\n_problem_type::Union{Nothing, EAGO.DIFF_CVX, EAGO.LP, EAGO.MILP, EAGO.MINCVX, EAGO.MISOCP, EAGO.SOCP}: Problem classification (set in parse_classify_problem!)\n_objective_saf::MathOptInterface.ScalarAffineFunction{Float64}: Stores the objective and is used for constructing linear affine cuts\n_objective::Union{Nothing, MathOptInterface.VariableIndex, EAGO.AffineFunctionIneq, EAGO.BufferedQuadraticIneq, EAGO.BufferedNonlinearFunction}: Storage for the objective function\n_optimization_sense::MathOptInterface.OptimizationSense: Objective sense information (set by MOI.set(m, ::ObjectiveSense...))\n_saf_leq::Vector{EAGO.AffineFunctionIneq}\n_saf_eq::Vector{EAGO.AffineFunctionEq}\n_sqf_leq::Vector{EAGO.BufferedQuadraticIneq}\n_sqf_eq::Vector{EAGO.BufferedQuadraticEq}\n_conic_second_order::Vector{EAGO.BufferedSOC}\n_nlp_data::Union{Nothing, MathOptInterface.NLPBlockData}\n_nonlinear_constr::Vector{EAGO.BufferedNonlinearFunction}\n_relaxed_evaluator::Evaluator\n_variable_info::Vector{VariableInfo{Float64}}: Variable information (set in initial_parse!)\n_variable_count::Int64: Count for the number of variables\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.Relax-dev-api_types","page":"Types","title":"EAGO.Relax","text":"Relax\n\nUsed to dispatch relaxations to a standard \n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.RelaxAA-dev-api_types","page":"Types","title":"EAGO.RelaxAA","text":"RelaxAA\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.RelaxMulEnum-dev-api_types","page":"Types","title":"EAGO.RelaxMulEnum","text":"RelaxMulEnum\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.RelaxResultStatus-dev-api_types","page":"Types","title":"EAGO.RelaxResultStatus","text":"RelaxResultStatus\n\nStatus code used internally to determine how to interpret the results from the solution of a relaxed problem.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.SIPHybrid-dev-api_types","page":"Types","title":"EAGO.SIPHybrid","text":"SIPHybrid\n\nSpecifies 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.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.SIPProblem-dev-api_types","page":"Types","title":"EAGO.SIPProblem","text":" SIPProblem\n\nStructure storing problem information for the solution routine.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.SIPRes-dev-api_types","page":"Types","title":"EAGO.SIPRes","text":"SIPRes\n\nSpecifies 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.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.SIPResRev-dev-api_types","page":"Types","title":"EAGO.SIPResRev","text":"SIPResRev\n\nSpecifies 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.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.SIPResult-dev-api_types","page":"Types","title":"EAGO.SIPResult","text":"SIPResult\n\nStructure storing the results of the SIPRes algorithm.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.SIPSubResult-dev-api_types","page":"Types","title":"EAGO.SIPSubResult","text":"SIPBuffer\n\nHold objective value, solution, discretization set, and feasibility status of each subproblem encountered by SIP algorithm.\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.SubSolvers-dev-api_types","page":"Types","title":"EAGO.SubSolvers","text":"mutable struct SubSolvers{Q<:MathOptInterface.AbstractOptimizer, S<:MathOptInterface.AbstractOptimizer, T<:ExtensionType}\n\nA structure containing the relaxed and upper optimizers to be used, as well as any user-defined extension.\n\nrelaxed_optimizer::MathOptInterface.AbstractOptimizer: Optimizer used to solve relaxed subproblems. Set using r = [...] (<: MOI.AbstractOptimizer) (default = Cbc.Optimizer())\nupper_optimizer::MathOptInterface.AbstractOptimizer: Optimizer used to solve upper bounding problems. Set using u = [...] (<: MOI.AbstractOptimizer) (default = Ipopt.Optimizer())\next::ExtensionType: User-defined extension to use. Set using t = [...](<: EAGO.ExtensionType)\n\n\n\n\n\n","category":"type"},{"location":"dev/api_types/#EAGO.VariableInfo-dev-api_types","page":"Types","title":"EAGO.VariableInfo","text":"struct VariableInfo{T<:AbstractFloat}\n\nA structure used to store information related to the bounds assigned to each variable.\n\nis_integer::Bool: Is the variable integer valued?\nhas_lower_bound::Bool: Boolean indicating whether a finite lower bound exists.\nhas_upper_bound::Bool: Boolean indicating whether a finite upper bound exists.\nis_fixed::Bool: Boolean indicating if variable is fixed to a finite value.\nhas_constraints::Bool: Boolean indicating that constraints have been set\nlower_bound::AbstractFloat: Lower bound. May be -Inf.\nupper_bound::AbstractFloat: Upper bound. May be Inf.\n\n\n\n\n\n","category":"type"},{"location":"examples/quasiconvex/#Advanced-Use-Example-1","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"","category":"section"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"This example is also provided here as a Jupyter Notebook.","category":"page"},{"location":"examples/quasiconvex/#Customizing-EAGO-to-Solve-a-Quasiconvex-Problem","page":"Advanced-Use Example 1","title":"Customizing EAGO to Solve a Quasiconvex Problem","text":"","category":"section"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"In this example, we'll adapt EAGO to implement the bisection-based algorithm used to solve a quasiconvex optimization problem presented in [1]:","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"beginaligned\nf^* = min_mathbf y in Y f(mathbf y) \nrm st sum_i = 1^5 i cdot y_i - 5 = 0 \n sum_i = 1^5 y_i^2 - 05 pi leq 0 \n -bigg(frac12 y_1^2 + frac12 y_2^2 + 2 y_1 y_2 + 4 y_1 y_3 + 2 y_2 y_3 bigg) leq 0 \n -y_1^2 - 6 y_1 y_2 - 2 y_2^2 + cos (y_1) + pi leq 0 \n Y = 0 5^5\nendaligned","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"where","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"beginaligned\nf(mathbf y) = -fracln ((5 + y_1)^2 + sum_i = 1^5 y_i)1 + sum_i = 1^5 y_i^2\nendaligned","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"Interval analysis shows that the objective value is bounded by the interval F such that f^* in F = f^L f^U = -5 0. Introducing an auxiliary variable t in T = F allows the problem to be formulated as:","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"beginaligned\nt^* = min_mathbf y in Y t in T t \nrm st (24) - (27) \n f(mathbf y) - t leq 0 \n Y = 05^2 T = -50\nendaligned","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"Let phi_tau(mathbf y) = f(mathbf y) - tau such that tau = (t^L + t^U)2. We solve for mathbf y subject to constraints (24) - (27) where phi_tau (mathbf y) leq 0. If this is feasible, t^* in t^Ltau, else t^* in τ t^U. The interval containing t^* is kept and the other is fathomed. This manner of bisection is repeated until an interval containing a feasible solution with a width of at most epsilon is located [2].","category":"page"},{"location":"examples/quasiconvex/#Customizing-EAGO's-Script","page":"Advanced-Use Example 1","title":"Customizing EAGO's Script","text":"","category":"section"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"First, the preprocessing step, upper problem, and postprocessing routines are short-circuited as only a single optimization problem needs to be solved at each iteration.","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"using MathOptInterface, EAGO, JuMP\nimport EAGO: Optimizer, GlobalOptimizer\n\nstruct QuasiConvex <: EAGO.ExtensionType end\nimport EAGO: preprocess!, upper_problem!, postprocess!\nfunction EAGO.preprocess!(t::QuasiConvex, x::GlobalOptimizer)\n x._preprocess_feasibility = true\nend\nfunction EAGO.upper_problem!(t::QuasiConvex, x::GlobalOptimizer)\n x._upper_feasibility = true\nend\nfunction EAGO.postprocess!(t::QuasiConvex, x::GlobalOptimizer)\n x._postprocess_feasibility = true\nend","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"Next, we specify that only an absolute tolerance should be checked for convergence and termination.","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"import EAGO: convergence_check, termination_check\nfunction EAGO.convergence_check(t::QuasiConvex, x::GlobalOptimizer)\n gap = (x._upper_objective_value - x._lower_objective_value)\n return (gap <= x._parameters.absolute_tolerance)\nend\nfunction EAGO.termination_check(t::QuasiConvex, x::GlobalOptimizer)\n flag = EAGO.convergence_check(t, x)\n if flag\n x._end_state = EAGO.GS_OPTIMAL\n x._termination_status_code = MathOptInterface.OPTIMAL\n x._result_status_code = MathOptInterface.FEASIBLE_POINT\n end\n return flag\nend","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"We then indicate that only the sixth variable, representing t, should be branched on. Since we will apply our knowledge about which t^* should be kept in the lower problem definition, we also short-circuit the EAGO.repeat_check function here to tell EAGO not to branch this node, but instead to repeatedly evaluate it.","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"import EAGO: repeat_check\nbranch_variable = [i == 6 for i=1:6]\nEAGO.repeat_check(t::QuasiConvex, x::GlobalOptimizer) = true","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"In the lower problem, we then specify that the problem is to be solved locally for a fixed t value. The objective value is then updated and the problem is contracted in order to discard the region which is known to not contain the optimal value.","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"import EAGO: lower_problem!\nfunction EAGO.lower_problem!(t::QuasiConvex, x::GlobalOptimizer)\n y = x._current_node\n indx = x._sol_to_branch_map[6]\n lower = y.lower_variable_bounds[indx]\n upper = y.upper_variable_bounds[indx]\n midy = (lower + upper)/2.0\n y.lower_variable_bounds[indx] = midy\n y.upper_variable_bounds[indx] = midy\n EAGO.solve_local_nlp!(x)\n feas = x._upper_feasibility\n y.lower_variable_bounds[indx] = feas ? lower : midy\n y.upper_variable_bounds[indx] = feas ? midy : upper\n x._lower_objective_value = y.lower_variable_bounds[indx]\n x._upper_objective_value = y.upper_variable_bounds[indx]\n x._lower_feasibility = true\n return\nend","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"We now define the optimizer factory to extend the core EAGO optimizer for this special problem. The SubSolvers constructor is used to set the extension type (t), as well as the relaxed optimizer (r) and upper-bounding optimizer (u), if necessary. In this case, we will use the default solvers and only set the extension type.","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"factory = () -> Optimizer(SubSolvers(; t = QuasiConvex()))","category":"page"},{"location":"examples/quasiconvex/#Construct-the-JuMP-Model-and-Optimize","page":"Advanced-Use Example 1","title":"Construct the JuMP Model and Optimize","text":"","category":"section"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"We now build the JuMP [3] model representing this problem, solve it, and retrieve the solution.","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"opt = optimizer_with_attributes(factory, \n \"absolute_tolerance\" => 1E-8, \n \"branch_variable\" => branch_variable,\n \"iteration_limit\" => 1000)\nm = Model(opt)\n@variable(m, ((i<6) ? 0.0 : -5.0) <= y[i=1:6] <= ((i<6) ? 5.0 : 0.0))\n@constraint(m, sum(i*y[i] for i=1:5) - 5.0 == 0.0)\n@constraint(m, sum(y[i]^2 for i=1:5) - 0.5*pi^2 <= 0.0)\n@expression(m, expr1, 2.0*y[1]*y[2] + 4.0*y[1]*y[3] + 2.0*y[2]*y[3])\n@constraint(m, -(0.5*y[1]^2 + 0.5*y[2]^2 + y[3]^2 + expr1) <= 0.0)\n@NLexpression(m, expr2, log((5.0 + y[1])^2 + sum(y[i] for i=1:5)))\n@NLconstraint(m, -y[1]^2 - 6.0*y[1]*y[2] - 2.0*y[2]^2 + cos(y[1]) + pi <= 0.0)\n@NLconstraint(m, -expr2/(1.0 + sum(y[i]^2 for i=1:5)) - y[6] <= 0.0)\n@objective(m, Min, y[6])\n\nJuMP.optimize!(m)","category":"page"},{"location":"examples/quasiconvex/#Retrieve-Results","page":"Advanced-Use Example 1","title":"Retrieve Results","text":"","category":"section"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"We then recover the solution values and the objective value using standard JuMP syntax.","category":"page"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"solution = JuMP.value.(y[1:5])\nglobal_obj_value = JuMP.value.(y[6])\nprint(\"Global solution at y*=$solution with a value of f*=$global_obj_value\")","category":"page"},{"location":"examples/quasiconvex/#References","page":"Advanced-Use Example 1","title":"References","text":"","category":"section"},{"location":"examples/quasiconvex/","page":"Advanced-Use Example 1","title":"Advanced-Use Example 1","text":"C. Jansson, Quasiconvex relaxations based on interval arithmetic, Linear Algebra and its Applications, 324 (2001), pp. 27–53.\nS. Boyd and L. Vandenberghe, Convex optimization, Cambridge University Press, 2004.\nIain Dunning and Joey Huchette and Miles Lubin. JuMP: A Modeling Language for Mathematical Optimization, SIAM Review, 59 (2017), pp. 295-320.","category":"page"},{"location":"semiinfinite/semiinfinite/#Solving-Semi-Infinite-Programs","page":"Semi-Infinite Programming","title":"Solving Semi-Infinite Programs","text":"","category":"section"},{"location":"semiinfinite/semiinfinite/#Using-EAGO-to-Solve-a-Semi-Infinite-Program","page":"Semi-Infinite Programming","title":"Using EAGO to Solve a Semi-Infinite Program","text":"","category":"section"},{"location":"semiinfinite/semiinfinite/","page":"Semi-Infinite Programming","title":"Semi-Infinite Programming","text":"This example is also provided here as a Jupyter Notebook.","category":"page"},{"location":"semiinfinite/semiinfinite/","page":"Semi-Infinite Programming","title":"Semi-Infinite Programming","text":"Semi-infinite programming remains an active area of research. In general, the solutions of semi-infinite programs (SIPs) with nonconvex semi-infinite constraints of the following form are extremely challenging:","category":"page"},{"location":"semiinfinite/semiinfinite/","page":"Semi-Infinite Programming","title":"Semi-Infinite Programming","text":"beginaligned\nf^* = min_mathbf x in X f(mathbf x) \nrm st g(mathbf x mathbf p) leq 0 forall mathbf p in P \n mathbf x in X = mathbf x in mathbb R^n_x mathbf x^L leq mathbf x leq mathbf x^U \n P = mathbf p in mathbb R^n_p mathbf p^L leq mathbf p leq mathbf p^U \nendaligned","category":"page"},{"location":"semiinfinite/semiinfinite/","page":"Semi-Infinite Programming","title":"Semi-Infinite Programming","text":"EAGO implements three different algorithms detailed in [1, 2] to determine a globally optimal solution to problems of the above form. This is accomplished using the sip_solve function which returns the optimal value, the solution, and a boolean feasibility flag. To illustrate the use of this function, a simple example is presented here which solves the problem:","category":"page"},{"location":"semiinfinite/semiinfinite/","page":"Semi-Infinite Programming","title":"Semi-Infinite Programming","text":"beginaligned\nf(mathbf x) = frac13 x_1^2 + x_2^2 + fracx_12 \ng(mathbf x p) = (1 - x_1^2 p^2)^2 - x_1 p^2 - x_2^2 + x_2 leq 0 \n mathbf x in X = -1000 1000^2 \n p in P = 0 1\nendaligned","category":"page"},{"location":"semiinfinite/semiinfinite/","page":"Semi-Infinite Programming","title":"Semi-Infinite Programming","text":"using EAGO, JuMP\n\n# Define semi-infinite program\nf(x) = (1/3)*x[1]^2 + x[2]^2 + x[1]/2\ngSIP(x, p) = (1.0 - x[1]^2*p[1]^2)^2 - x[1]*p[1]^2 - x[2]^2 + x[2]\n\nx_l = Float64[-1000.0, -1000.0]\nx_u = Float64[1000.0, 1000.0]\np_l = Float64[0.0]\np_u = Float64[1.0]\n\nsip_result = sip_solve(SIPRes(), x_l, x_u, p_l, p_u, f, Any[gSIP], res_sip_absolute_tolerance = 1E-3);","category":"page"},{"location":"semiinfinite/semiinfinite/#Semi-Infinite-Solver","page":"Semi-Infinite Programming","title":"Semi-Infinite Solver","text":"","category":"section"},{"location":"semiinfinite/semiinfinite/","page":"Semi-Infinite Programming","title":"Semi-Infinite Programming","text":" SIPProblem\n SIPResult\n SIPRes\n SIPResRev\n SIPHybrid\n get_sip_optimizer\n build_model\n sip_llp!\n sip_bnd!\n sip_res!\n sip_solve","category":"page"},{"location":"semiinfinite/semiinfinite/#EAGO.SIPProblem","page":"Semi-Infinite Programming","title":"EAGO.SIPProblem","text":" SIPProblem\n\nStructure storing problem information for the solution routine.\n\n\n\n\n\n","category":"type"},{"location":"semiinfinite/semiinfinite/#EAGO.SIPResult","page":"Semi-Infinite Programming","title":"EAGO.SIPResult","text":"SIPResult\n\nStructure storing the results of the SIPRes algorithm.\n\n\n\n\n\n","category":"type"},{"location":"semiinfinite/semiinfinite/#EAGO.SIPRes","page":"Semi-Infinite Programming","title":"EAGO.SIPRes","text":"SIPRes\n\nSpecifies 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.\n\n\n\n\n\n","category":"type"},{"location":"semiinfinite/semiinfinite/#EAGO.SIPResRev","page":"Semi-Infinite Programming","title":"EAGO.SIPResRev","text":"SIPResRev\n\nSpecifies 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.\n\n\n\n\n\n","category":"type"},{"location":"semiinfinite/semiinfinite/#EAGO.SIPHybrid","page":"Semi-Infinite Programming","title":"EAGO.SIPHybrid","text":"SIPHybrid\n\nSpecifies 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.\n\n\n\n\n\n","category":"type"},{"location":"semiinfinite/semiinfinite/#EAGO.get_sip_optimizer","page":"Semi-Infinite Programming","title":"EAGO.get_sip_optimizer","text":"get_sip_optimizer\n\nSpecifices the optimizer to be used in extension t::EAGO.ExtensionType with algorithm alg::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command get_sip_optimizer(t::ExtensionType, alg::AbstractSIPAlgo, s::AbstractSubproblemType).\n\n\n\n\n\n","category":"function"},{"location":"semiinfinite/semiinfinite/#EAGO.build_model","page":"Semi-Infinite Programming","title":"EAGO.build_model","text":"build_model\n\nCreate the model and variables used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command build_model(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, p::SIPProblem).\n\n\n\n\n\n","category":"function"},{"location":"semiinfinite/semiinfinite/#EAGO.sip_llp!","page":"Semi-Infinite Programming","title":"EAGO.sip_llp!","text":"sip_llp!\n\nSolves the lower level problem for the ith-SIP used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_llp!(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, ..., i, tol).\n\n\n\n\n\n","category":"function"},{"location":"semiinfinite/semiinfinite/#EAGO.sip_bnd!","page":"Semi-Infinite Programming","title":"EAGO.sip_bnd!","text":"sip_bnd!\n\nSolves the bounding problem for the ith-SIP used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_bnd!(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, ..., i, tol).\n\n\n\n\n\n","category":"function"},{"location":"semiinfinite/semiinfinite/#EAGO.sip_res!","page":"Semi-Infinite Programming","title":"EAGO.sip_res!","text":"sip_res!\n\nSolves the restriction problem for extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_res!(t::ExtensionType, a::AbstractSIPAlgo, ...).\n\n\n\n\n\n","category":"function"},{"location":"semiinfinite/semiinfinite/#EAGO.sip_solve","page":"Semi-Infinite Programming","title":"EAGO.sip_solve","text":"sip_solve\n\nSolve an SIP with decision variable bounds x_l to x_u, uncertain variable bounds p_l to p_u, an objective function of f, and gSIP seminfiniite constraint(s).\n\n\n\n\n\n","category":"function"},{"location":"semiinfinite/semiinfinite/#References","page":"Semi-Infinite Programming","title":"References","text":"","category":"section"},{"location":"semiinfinite/semiinfinite/","page":"Semi-Infinite Programming","title":"Semi-Infinite Programming","text":"Mitsos A (2009). Global optimization of semi-infinite programs via restriction of the right-hand side. Optimization, 60(10-11):1291-1308.\nDjelassi, 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.","category":"page"},{"location":"examples/interval_bb/#Standard-Use-Example-2","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"This example is also provided here as a Jupyter Notebook.","category":"page"},{"location":"examples/interval_bb/#Using-EAGO's-Basic-Optimizer-With-User-Defined-Subroutines","page":"Standard-Use Example 2","title":"Using EAGO's Basic Optimizer With User-Defined Subroutines","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"In this section, we construct an optimizer that uses EAGO's basic NLP solution routine with user-defined lower and upper-bounding problems. The Optimizer structure supplies a number of parameters and stored structures that advanced users may find useful for constructing specialized solution routines.","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"In this example, we'll forgo extensive integration into the Optimizer and simply replace the lower and upper-bounding problems to construct a B&B routine that solves the following problem to global optimality using bounds obtained from interval arithmetic:","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"beginaligned\n min_mathbf x in X sin(x_1) x_2^2 - cos(x_3) x_4 \n X = -10 10 times -1 1 times -10 10 times 2 20\nendaligned","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"We begin by importing EAGO, IntervalArithmetic [1], and JuMP [2].","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"using EAGO, IntervalArithmetic, JuMP","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"We now define the IntervalExt struct as a subtype of the ExtensionType.","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"struct IntervalExt <: EAGO.ExtensionType end","category":"page"},{"location":"examples/interval_bb/#Define-a-Custom-Lower-Bounding-Problem","page":"Standard-Use Example 2","title":"Define a Custom Lower-Bounding Problem","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"A valid lower bound is obtained from the lower bound of the natural interval extension using the IntervalArithmetic.jl [1] package. The LowerProblem is dispatched using the new IntervalExt structure and the GlobalOptimizer structure, computes the bound using interval arithmetic, and stores the results to the appropriate field of the GlobalOptimizer. Note that the problem is unconstrained on the domain so we can assume it is always feasible. Further, since the interval bound is constrained along the entire domain associated with a node, no additional cuts will be beneficial and thus we've disabled them using the _cut_add_flag field.","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"import EAGO: lower_problem!\nfunction lower_problem!(t::IntervalExt, x::EAGO.GlobalOptimizer)\n # Retrieve bounds at current node\n n = x._current_node\n lower = n.lower_variable_bounds\n upper = n.upper_variable_bounds\n \n # Define X for the node and compute the interval extension\n x_value = Interval.(lower, upper)\n F = sin(x_value[1])*x_value[2]^2 - cos(x_value[3])/x_value[4]\n x._lower_objective_value = F.lo\n x._lower_solution = IntervalArithmetic.mid.(x_value)\n x._lower_feasibility = true\n x._cut_add_flag = false\n \n return\nend","category":"page"},{"location":"examples/interval_bb/#Define-a-Custom-Upper-Bounding-Problem","page":"Standard-Use Example 2","title":"Define a Custom Upper-Bounding Problem","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"Since the problem is unconstrained, any feasible point represents a valid upper bound. Thus, if we arbitrarily evaluate the function at the midpoint, we obtain a valid upper bound. This function constructs an upper bound in this manner then stores the results to the appropriate field of the GlobalOptimizer.","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"import EAGO.upper_problem!\nfunction EAGO.upper_problem!(t::IntervalExt, x::EAGO.GlobalOptimizer)\n # Retrieve bounds at current node\n n = x._current_node\n lower = n.lower_variable_bounds\n upper = n.upper_variable_bounds\n \n # Compute midpoint value and evaluate at that point\n x_value = 0.5*(upper + lower)\n f_val = sin(x_value[1])*x_value[2]^2-cos(x_value[3])/x_value[4]\n x._upper_objective_value = f_val\n x._upper_solution = x_value\n x._upper_feasibility = true\n \n return\nend","category":"page"},{"location":"examples/interval_bb/#Disable-Unnecessary-Routines","page":"Standard-Use Example 2","title":"Disable Unnecessary Routines","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"It is entirely possible to disable domain reduction by manipulating keyword arguments supplied to the optimizer. However, for simplicity's sake we'll simply overload the default preprocessing and postprocessing methods and indicate that there are no conditions under which EAGO should cut the node.","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"import EAGO: preprocess!, postprocess!, cut_condition\nfunction EAGO.preprocess!(t::IntervalExt, x::EAGO.GlobalOptimizer)\n x._preprocess_feasibility = true\n return\nend\nfunction EAGO.postprocess!(t::IntervalExt, x::EAGO.GlobalOptimizer)\n x._postprocess_feasibility = true\n return\nend\nEAGO.cut_condition(t::IntervalExt, x::EAGO.GlobalOptimizer) = false","category":"page"},{"location":"examples/interval_bb/#Construct-the-JuMP-Model-and-Optimize","page":"Standard-Use Example 2","title":"Construct the JuMP Model and Optimize","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"We now add our optimizer to a JuMP [2] model, provide variable bounds, and optimize.","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"# Create a factory that specifies the interval extension in EAGO's SubSolver\nfactory = () -> EAGO.Optimizer(SubSolvers(; t = IntervalExt()))\n\n# Create a JuMP model using the factory, and with the absolute tolerance set by keyword argument\nm = Model(optimizer_with_attributes(factory,\n \"absolute_tolerance\" => 0.001\n ))\n\n# Add variables, bounds, and the objective function\nx_L = [-10.0, -1.0, -10.0, 2.0]\nx_U = [10.0, 1.0, 10.0, 20.0]\n@variable(m, x_L[i] <= x[i=1:4] <= x_U[i])\n@NLobjective(m, Min, sin(x[1])*x[2]^2 - cos(x[3])/x[4])\n\n# Perform the optimization\noptimize!(m)","category":"page"},{"location":"examples/interval_bb/#Retrieve-Results","page":"Standard-Use Example 2","title":"Retrieve Results","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"The objective value, solution, termination status, and primal status can then be accessed via the standard JuMP interface.","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"fval = JuMP.objective_value(m)\nxsol = JuMP.value.(x)\nstatus_term = JuMP.termination_status(m)\nstatus_prim = JuMP.primal_status(m)\n\nprintln(\"EAGO terminated with a status of $status_term and a result code of $status_prim\")\nprintln(\"The optimal value is: $(round(fval, digits=3)), the solution found is $(round.(xsol, digits=4)).\")","category":"page"},{"location":"examples/interval_bb/#Advice-for-More-Advanced-Constructions","page":"Standard-Use Example 2","title":"Advice for More Advanced Constructions","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"The default lower_problem! and upper_problem! should be used as templates for error handling and retrieving information from MOI models.","category":"page"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"Essentially all of EAGO's subroutines stored to a field in the Optimizer structure can be reset as user-defined functions.","category":"page"},{"location":"examples/interval_bb/#References","page":"Standard-Use Example 2","title":"References","text":"","category":"section"},{"location":"examples/interval_bb/","page":"Standard-Use Example 2","title":"Standard-Use Example 2","text":"IntervalArithmetic.jl [Computer software] (2019). Retrieved from https://github.com/JuliaIntervals/IntervalArithmetic.jl\nIain Dunning and Joey Huchette and Miles Lubin. JuMP: A Modeling Language for Mathematical Optimization, SIAM Review, SIAM 59 (2017), pp. 295-320.","category":"page"},{"location":"cite/#Citing-EAGO","page":"Citing EAGO","title":"Citing EAGO","text":"","category":"section"},{"location":"cite/","page":"Citing EAGO","title":"Citing EAGO","text":"Please cite the following paper when using EAGO.jl:","category":"page"},{"location":"cite/","page":"Citing EAGO","title":"Citing EAGO","text":"Wilhelm, M.E. and Stuber, M.D. EAGO.jl: easy advanced global optimization in Julia.\nOptimization Methods and Software. 37(2): 425-450 (2022). DOI: 10.1080/10556788.2020.1786566","category":"page"},{"location":"dev/api_functions/#Functions","page":"Functions","title":"Functions","text":"","category":"section"},{"location":"dev/api_functions/","page":"Functions","title":"Functions","text":"Modules = [EAGO]\nOrder = [:function]","category":"page"},{"location":"dev/api_functions/#EAGO._add_constraint_store_ci!-Union{Tuple{S}, Tuple{F}, Tuple{Any, InputProblem, Type{F}, Type{S}}} where {F, S}-dev-api_functions","page":"Functions","title":"EAGO._add_constraint_store_ci!","text":"_add_constraint_store_ci!(\n d,\n m::InputProblem,\n _::Type{F},\n _::Type{S}\n)\n\n\nAdd a constraint to the local problem, storing the new constraint index and the associated index in the input problem.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._add_constraint_store_ci_linear!-Tuple{Any, InputProblem}-dev-api_functions","page":"Functions","title":"EAGO._add_constraint_store_ci_linear!","text":"_add_constraint_store_ci_linear!(d, ip::InputProblem)\n\n\nAdd linear constraints to the local problem, storing the new constraint indices and the associated indices in the input problem.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._add_constraint_store_ci_quadratic!-Tuple{Any, InputProblem}-dev-api_functions","page":"Functions","title":"EAGO._add_constraint_store_ci_quadratic!","text":"_add_constraint_store_ci_quadratic!(d, ip::InputProblem)\n\n\nAdd quadratic constraints to the local problem, storing the new constraint indices and the associated indices in the input problem.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._bvi-Tuple{GlobalOptimizer, Int64}-dev-api_functions","page":"Functions","title":"EAGO._bvi","text":"_bvi(m::GlobalOptimizer, i::Int64) -> Int64\n\n\nReturn the branch-to-sol mapping for the i'th variable.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._constraint_primal-Union{Tuple{S}, Tuple{F}, Tuple{GlobalOptimizer, Type{F}, Type{S}}} where {F, S}-dev-api_functions","page":"Functions","title":"EAGO._constraint_primal","text":"_constraint_primal\n\nHelper function which simplifies finding constraints of different types. See also: _constraints\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._constraints-Tuple{Optimizer, Type{MathOptInterface.VariableIndex}, Type{MathOptInterface.LessThan{Float64}}}-dev-api_functions","page":"Functions","title":"EAGO._constraints","text":"_constraints\n\nHelper function which simplifies finding constraints of different types. See also: _constraint_primal\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._diam-Tuple{EAGO.BranchVar, GlobalOptimizer, Int64}-dev-api_functions","page":"Functions","title":"EAGO._diam","text":"_diam(::BranchVar, ::GlobalOptimizer, ::Int)\n_diam(::FullVar, ::GlobalOptimizer, ::Int)\n\nReturn the diameter of a variable (upper bound - lower bound).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._ext-Union{Tuple{SubSolvers{Q, S, T}}, Tuple{T}, Tuple{S}, Tuple{Q}} where {Q<:MathOptInterface.AbstractOptimizer, S<:MathOptInterface.AbstractOptimizer, T<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO._ext","text":"_ext(::Optimizer)\n_ext(::GlobalOptimizer)\n_ext(::SubSolvers)\n\nReturn the extension (<: ExtensionType) from the SubSolvers (sub)field or object.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._extract_primal!-Union{Tuple{S}, Tuple{F}, Tuple{Any, InputProblem, Type{F}, Type{S}}} where {F, S}-dev-api_functions","page":"Functions","title":"EAGO._extract_primal!","text":"_extract_primal!(d, m::InputProblem, _::Type{F}, _::Type{S})\n\n\nExtract primal constraint value from the local problem and save the result to the appropriate field of the optimizer.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._extract_primal_linear!-Tuple{Any, InputProblem}-dev-api_functions","page":"Functions","title":"EAGO._extract_primal_linear!","text":"_extract_primal_linear!(d, ip::InputProblem)\n\n\nExtract linear primal constraint values from the local problem and save the result to the appropriate field of the optimizer.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._extract_primal_quadratic!-Tuple{Any, InputProblem}-dev-api_functions","page":"Functions","title":"EAGO._extract_primal_quadratic!","text":"_extract_primal_quadratic!(d, ip::InputProblem)\n\n\nExtract quadratic primal constraint values from the local problem and save the result to the appropriate field of the optimizer.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._is_branch_var-Tuple{GlobalOptimizer, Any}-dev-api_functions","page":"Functions","title":"EAGO._is_branch_var","text":"_is_branch_var(m::GlobalOptimizer, i) -> Any\n\n\nCheck if m._branch_variables[i] is true or false.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._is_input_min-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO._is_input_min","text":"_is_input_min(m::GlobalOptimizer) -> Bool\n\n\nCheck to see if the sense of the optimization problem is Min (true) or Max (false).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._relaxed_optimizer-Union{Tuple{SubSolvers{Q, S, T}}, Tuple{T}, Tuple{S}, Tuple{Q}} where {Q<:MathOptInterface.AbstractOptimizer, S<:MathOptInterface.AbstractOptimizer, T<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO._relaxed_optimizer","text":"_relaxed_optimizer(::GlobalOptimizer)\n_relaxed_optimizer(::SubSolvers)\n\nReturn the relaxed optimizer (<: MOI.AbstractOptimizer) from the SubSolvers field or object.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._svi-Tuple{GlobalOptimizer, Int64}-dev-api_functions","page":"Functions","title":"EAGO._svi","text":"_svi(m::GlobalOptimizer, i::Int64) -> Int64\n\n\nReturn the sol-to-branch mapping for the i'th variable.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO._upper_optimizer-Union{Tuple{SubSolvers{Q, S, T}}, Tuple{T}, Tuple{S}, Tuple{Q}} where {Q<:MathOptInterface.AbstractOptimizer, S<:MathOptInterface.AbstractOptimizer, T<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO._upper_optimizer","text":"_upper_optimizer(::GlobalOptimizer)\n_upper_optimizer(::SubSolvers)\n\nReturn the upper optimizer (<: MOI.AbstractOptimizer) from the SubSolvers field or object.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.add_nonlinear!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.add_nonlinear!","text":"add_nonlinear!(m::GlobalOptimizer)\n\n\nAdd an Evaluator and nonlinear functions and populate each appropriately.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.add_nonlinear_evaluator!-Tuple{GlobalOptimizer, Nothing}-dev-api_functions","page":"Functions","title":"EAGO.add_nonlinear_evaluator!","text":"add_nonlinear_evaluator!\n\nAdd an Evaluator structure if nonlinear terms are attached.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.add_objective!-Tuple{ParsedProblem, Any}-dev-api_functions","page":"Functions","title":"EAGO.add_objective!","text":"add_objective!\n\nAdd objective function (if any) to the parsed problem.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.affine_relax_quadratic!-Tuple{GlobalOptimizer, MathOptInterface.ScalarQuadraticFunction{Float64}, Dict{Int64, Float64}, MathOptInterface.ScalarAffineFunction{Float64}}-dev-api_functions","page":"Functions","title":"EAGO.affine_relax_quadratic!","text":"affine_relax_quadratic!\n\nDefault routine for relaxing quadratic constraint func < 0.0 on node n. Takes affine bounds of convex part at point x0 and secant line bounds on concave parts.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.aggressive_filtering!-Union{Tuple{Q}, Tuple{S}, Tuple{R}, Tuple{GlobalOptimizer{R, S, Q}, NodeBB}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.aggressive_filtering!","text":"aggressive_filtering!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType},\n n::NodeBB\n) -> Bool\n\n\nExcludes OBBT on variable indices after a search in a filtering direction.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.bool_indx_diff!-Tuple{Vector{Bool}, Vector{Bool}, Vector{Bool}}-dev-api_functions","page":"Functions","title":"EAGO.bool_indx_diff!","text":"bool_indx_diff!(\n z::Vector{Bool},\n x::Vector{Bool},\n y::Vector{Bool}\n) -> Vector{Bool}\n\n\nUtility function used to set vector of booleans z to x & ~y. Avoids the generation of conversion of the BitArray created by broadcasting logical operators.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.bound_objective-Tuple{GlobalOptimizer, EAGO.BufferedNonlinearFunction}-dev-api_functions","page":"Functions","title":"EAGO.bound_objective","text":"bound_objective(::GlobalOptimizer, ::T)\nbound_objective(::ExtensionType, ::GlobalOptimizer)\n\nCompute a tuple representing the lower and upper bounds for an objective function. Note: bound_objective(::GlobalOptimizer) dispatches to bound_objective(::ExtensionType, ::GlobalOptimizer).\n\nOptions for T:\n\nAffineFunctionIneq\nBufferedNonlinearFunction\nBufferedQuadraticIneq\nMOI.VariableIndex\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.branch_node!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.branch_node!","text":"branch_node!(t::ExtensionType, m::GlobalOptimizer)\n\n\nCreate two nodes from current_node and store them on the stack. Call select_branch_variable(t, m) and select_branch_point(t, m, k) to determine the variable that should be branched on and the point at which branching should occur, respectively.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.build_model-Union{Tuple{S}, Tuple{A}, Tuple{EAGO.DefaultExt, A, S, SIPProblem}} where {A<:AbstractSIPAlgo, S<:AbstractSubproblemType}-dev-api_functions","page":"Functions","title":"EAGO.build_model","text":"build_model\n\nCreate the model and variables used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command build_model(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, p::SIPProblem).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.check_set_affine_nl!-Union{Tuple{Q}, Tuple{T}, Tuple{N}, Tuple{S}, Tuple{R}, Tuple{V}, Tuple{GlobalOptimizer{R, S, Q}, EAGO.BufferedNonlinearFunction{V, N, T}, Bool, Bool}} where {V, R, S, N, T<:RelaxTag, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.check_set_affine_nl!","text":"check_set_affine_nl!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType},\n f::EAGO.BufferedNonlinearFunction{V, N, T<:RelaxTag},\n finite_cut::Bool,\n check_safe::Bool\n) -> Bool\n\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.convergence_check-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.convergence_check","text":"convergence_check(\n t::ExtensionType,\n m::GlobalOptimizer\n) -> Bool\n\n\nCheck for problem convergence.\n\nBy default, check if the lower and upper bounds have converged to within absolute and/or relative tolerances.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.create_buffer_dict-Tuple{MathOptInterface.ScalarQuadraticFunction{Float64}}-dev-api_functions","page":"Functions","title":"EAGO.create_buffer_dict","text":"create_buffer_dict(\n func::MathOptInterface.ScalarQuadraticFunction{Float64}\n) -> Dict{Int64, Float64}\n\n\nCreate a buffer dictionary from a ScalarQuadraticFunction.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.cut-Union{Tuple{T}, Tuple{N}, Tuple{MC{N, T}, MC{N, T}, EAGO.VariableValues, Float64, Vector{Int64}, Bool, Bool}} where {N, T<:RelaxTag}-dev-api_functions","page":"Functions","title":"EAGO.cut","text":"cut\n\nIntersects the new set valued operator with the prior and performs affine bound tightening\n\nFirst forward pass: post should be set by user option, is_intersect should be false so that the tape overwrites existing values, and the interval_intersect flag could be set to either value.\nForward CP pass (assumes same reference point): post should be set by user option, is_intersect should be true so that the tape intersects with existing values, and the interval_intersect flag should be false.\nForward CP pass (assumes same reference point): post should be set by user option, is_intersect should be true so that the tape intersects with existing values, and the interval_intersect flag should be false.\nSubsequent forward passes at new points: postshould be set by user option,isintersectshould be true so that the tape intersects with existing values, and theintervalintersectflag should betrue` as predetermined interval bounds are valid but the prior values may correspond to different points of evaluation.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.cut_condition-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.cut_condition","text":"cut_condition(t::ExtensionType, m::GlobalOptimizer) -> Bool\n\n\nReturns true if a cut should be added and computes a new reference point to add the cut at. By default, checks that cut_max_iterations are not exceeded and that the improvement in the objective value associated with the previous cut is greater than both an absolute tolerance cut_ϵ_abs and a relative tolerance cut_ϵ_rel. Returns false otherwise.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.default_upper_heuristic-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.default_upper_heuristic","text":"default_upper_heuristic(m::GlobalOptimizer) -> Bool\n\n\nDefault check to see if the upper bounding problem should be run. By default, The upper bounding problem is run on every node up to depth upper_bounding_depth and is triggered with a probability of 0.5^(depth - upper_bounding_depth) afterwards for continuous problems. For integral problems, the upper_bounding_depth approach is used as well as running on every node up to depth upper_bounding_depth + cont_depth with another trigger of probability 0.5^(depth - upper_bounding_depth - cont_depth).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.diam-Union{Tuple{VariableInfo{T}}, Tuple{T}} where T<:AbstractFloat-dev-api_functions","page":"Functions","title":"EAGO.diam","text":"Return the diameter of a variable (upper bound - lower bound).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.eliminate_fixed_variables!-dev-api_functions","page":"Functions","title":"EAGO.eliminate_fixed_variables!","text":"eliminate_fixed_variables!(::T, ::Vector{VariableInfo})\n\nEliminate fixed variables by rearrangment or restructuring of the AbstractEAGOConstraint.\n\nOptions for T (all are subtypes of AbstractEAGOConstraint):\n\nAffineFunctionEq\nAffineFunctionIneq\nBufferedQuadraticIneq\nBufferedNonlinearFunction{N,T} where {N, T<:RelaxTag}\nNonlinearExpression{V,N,T} where {V, N, T<:RelaxTag}\n\n\n\n\n\n","category":"function"},{"location":"dev/api_functions/#EAGO.f_init!-Tuple{AbstractCacheAttribute, AbstractDirectedGraph, AbstractCache}-dev-api_functions","page":"Functions","title":"EAGO.f_init!","text":"Initializes information in cache c for each node in g that may be used in a forward-pass of attribute t. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.fathom!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.fathom!","text":"fathom!(t::ExtensionType, m::GlobalOptimizer)\n\n\nRemove nodes from the stack. By default, delete nodes from the stack if their lower bounds are greater than the current global upper bound.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.fbbt!-dev-api_functions","page":"Functions","title":"EAGO.fbbt!","text":"fbbt!(m::GlobalOptimizer, f::T)\n\nPerforms feasibility-based bound tightening on a back-end constraint and returns true if it is feasible or false if it is infeasible.\n\nOptions for T (all are subtypes of AbstractEAGOConstraint):\n\nAffineFunctionIneq\nAffineFunctionEq\n\n\n\n\n\n","category":"function"},{"location":"dev/api_functions/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Constant, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a constant v at index k in cache c associated with graph g using information at index k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Expression, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a expression v at index k in cache c associated with graph g using information taken from the children of k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Parameter, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a parameter v at index k in cache c associated with graph g using information at index k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Subexpression, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a subexpression v at index k in cache c associated with graph g using information taken from the children of k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.fprop!-Tuple{AbstractCacheAttribute, Variable, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.fprop!","text":"Populates information associated with attribute t for a variable v at index k in cache c associated with graph g using information at index k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.get_sip_optimizer-Union{Tuple{A}, Tuple{ExtensionType, A, AbstractSubproblemType}} where A<:AbstractSIPAlgo-dev-api_functions","page":"Functions","title":"EAGO.get_sip_optimizer","text":"get_sip_optimizer\n\nSpecifices the optimizer to be used in extension t::EAGO.ExtensionType with algorithm alg::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command get_sip_optimizer(t::ExtensionType, alg::AbstractSIPAlgo, s::AbstractSubproblemType).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.global_solve!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.global_solve!","text":"global_solve!(m::GlobalOptimizer)\n\n\nSolves the branch-and-bound problem with the input EAGO.GlobalOptimizer object.\n\nPseudocode description of the algorithm, as implemented here:\n\n-I) Prepare optimizers and stack for branch-and-bound\n\n-II) While no reason to terminate the algorithm has occurred:\n\n–-II.A) Fathom nodes from the stack\n\n–-II.B) Select the new \"current node\" from the stack\n\n–-II.C) Perform preprocessing on current node\n\n–-II.D) If preprocessing result is feasible:\n\n––-II.D.1) Solve lower problem for current node\n\n––-II.D.2) If lower problem result is feasible and lower/upper bounds have not converged:\n\n–––-II.D.2.a) Solve upper problem for current node\n\n–––-II.D.2.b) Update the global upper bound if necessary\n\n–––-II.D.2.c) Perform postprocessing\n\n–––-II.D.2.d) If postprocessing result is feasible:\n\n––––-II.D.2.d.α) Branch and add the nodes back to the stack\n\n–-II.E) Update the global lower bound if necessary\n\n–-II.F) Update log information\n\n-III) Set termination and result statuses\n\n-IV) Print solution\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.initial_parse!-Union{Tuple{Optimizer{R, S, T}}, Tuple{T}, Tuple{S}, Tuple{R}} where {R, S, T}-dev-api_functions","page":"Functions","title":"EAGO.initial_parse!","text":"initial_parse!(m::Optimizer{R, S, T})\n\n\nTranslate the input problem to the working problem. Any checks or optional manipulation are left to the presolve stage.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.initialize!-Tuple{AbstractCache, AbstractDirectedGraph}-dev-api_functions","page":"Functions","title":"EAGO.initialize!","text":"initialize!(_::AbstractCache, _::AbstractDirectedGraph)\n\n\nFunction used to initialize the storage cache d::AbstractCache for a given type of directed acyclic graph g::AbstractDirectedGraph.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.initialize_stack!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.initialize_stack!","text":"initialize_stack!(t::ExtensionType, m::GlobalOptimizer)\n\n\nPrepare the stack for the branch-and-bound routine. By default, create an initial node with the variable bounds as box constraints and add it to the stack.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.interval_bound-dev-api_functions","page":"Functions","title":"EAGO.interval_bound","text":"interval_bound(::GlobalOptimizer, ::T)\n\nCompute a tuple representing the lower and upper interval bounds for an AbstractEAGOConstraint representing an equality constraint.\n\nOptions for T (all are subtypes of AbstractEAGOConstraint):\n\nAffineFunctionEq\nAffineFunctionIneq\nBufferedQuadraticEq\nBufferedQuadraticIneq\nBufferedNonlinearFunction{V,N,T} where {V,N,T}\n\n\n\n\n\n","category":"function"},{"location":"dev/api_functions/#EAGO.interval_objective_bound!-dev-api_functions","page":"Functions","title":"EAGO.interval_objective_bound!","text":"\n\n\n\n","category":"function"},{"location":"dev/api_functions/#EAGO.is_feasible-Tuple{GlobalOptimizer, Union{EAGO.AffineFunctionIneq, EAGO.BufferedQuadraticIneq}}-dev-api_functions","page":"Functions","title":"EAGO.is_feasible","text":"is_feasible(::GlobalOptimizer, ::T)\n\nCheck if a given bound is feasible.\n\nOptions for T (all are subtypes of AbstractEAGOConstraint):\n\nAffineFunctionIneq\nAffineFunctionEq\nBufferedQuadraticIneq\nBufferedQuadraticEq\nBufferedNonlinearFunction{V,N,T}\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.is_integer_feasible_local-Tuple{GlobalOptimizer, Any}-dev-api_functions","page":"Functions","title":"EAGO.is_integer_feasible_local","text":"is_integer_feasible_local(m::GlobalOptimizer, d) -> Bool\n\n\nChecks that the solution of a local solve is integer feasible to within the tolerances specified by integer_abs_tol and integer_rel_tol.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.is_integer_feasible_relaxed-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.is_integer_feasible_relaxed","text":"is_integer_feasible_relaxed(m::GlobalOptimizer) -> Bool\n\n\nCheck that the solution of the lower (relaxed problem) is integer feasible to within tolerances specified by the parameters: integer_abs_tol (absolute tolerance) and integer_rel_tol (relative tolerance).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.is_integer_subproblem-Tuple{Any}-dev-api_functions","page":"Functions","title":"EAGO.is_integer_subproblem","text":"is_integer_subproblem(m)\n\n\nReturns true that the subproblem at the current node n has participating integer variables that have not been fixed to constant valued as the branch-and-bound algorithm progresses. Returns false otherwise.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.is_safe_cut!-Tuple{GlobalOptimizer, MathOptInterface.ScalarAffineFunction{Float64}}-dev-api_functions","page":"Functions","title":"EAGO.is_safe_cut!","text":"is_safe_cut!(\n m::GlobalOptimizer,\n f::MathOptInterface.ScalarAffineFunction{Float64}\n) -> Bool\n\n\nApplies the safe cut checks detailed in Khajavirad, 2018 [Khajavirad, Aida, and Nikolaos V. Sahinidis. \"A hybrid LP/NLP paradigm for global optimization relaxations.\" Mathematical Programming Computation 10.3 (2018): 383-421] to ensure that only numerically safe affine relaxations are added. Checks that:\n\n|b| <= safe b, \nsafe_l <= abs(ai) <= safe u, and \nsafe_l <= abs(ai/aj) <= safe_u.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.label_branch_variables!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.label_branch_variables!","text":"label_branch_variables!(m::GlobalOptimizer)\n\n\nDetect any variables participating in nonconvex terms and populate the _branch_variables storage array.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.label_fixed_variables!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.label_fixed_variables!","text":"label_fixed_variables!(m::GlobalOptimizer) -> Vector{Bool}\n\n\nDetect any variables set to a fixed value by equality or inequality constraints and populate the _fixed_variable storage array.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.load_fbbt_buffer!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.load_fbbt_buffer!","text":"load_fbbt_buffer!(m::GlobalOptimizer)\n\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.load_relaxed_problem!-Union{Tuple{GlobalOptimizer{R, S, Q}}, Tuple{Q}, Tuple{S}, Tuple{R}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.load_relaxed_problem!","text":"load_relaxed_problem!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType}\n)\n\n\nLoad variables, linear constraints, and empty storage space for the first NLP and quadratic cut into the relaxed optimizer.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.local_problem_status-Tuple{MathOptInterface.TerminationStatusCode, MathOptInterface.ResultStatusCode}-dev-api_functions","page":"Functions","title":"EAGO.local_problem_status","text":"local_problem_status(t, r)\n\n\nTakes an MOI.TerminationStatusCode and a MOI.ResultStatusCode and returns true if this corresponds to a solution that is proven to be feasible. Returns false otherwise.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.log_iteration!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.log_iteration!","text":"log_iteration!(m::GlobalOptimizer)\n\n\nIf log_on is true, the global_lower_bound, global_upper_bound, run_time, and node_count are stored every log_interval. If log_subproblem_info then the lower bound, feasibility and run times of the subproblems are logged every log_interval.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.lower_interval_bound-dev-api_functions","page":"Functions","title":"EAGO.lower_interval_bound","text":"lower_interval_bound(::GlobalOptimizer, ::T)\n\nCompute the lower interval bound for an AbstractEAGOConstraint representing an inequality constraint.\n\nOptions for T (all are subtypes of AbstractEAGOConstraint):\n\nAffineFunctionIneq\nBufferedQuadraticIneq\nBufferedSOC\nBufferedNonlinearFunction{V,N,T} where {V,N,T}\n\n\n\n\n\n","category":"function"},{"location":"dev/api_functions/#EAGO.lower_problem!-Union{Tuple{Q}, Tuple{S}, Tuple{R}, Tuple{ExtensionType, GlobalOptimizer{R, S, Q}}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.lower_problem!","text":"lower_problem!(\n t::ExtensionType,\n m::GlobalOptimizer{R, S, Q<:ExtensionType}\n)\n\n\nConstructs a relaxation of the MINLP on node y and solves it using the default EAGO relaxation scheme. By default, EAGO applies Kelley's algorithm (from Kelley Jr., J.E.: The cutting-plane method for solving convex programs. J. Soc. Ind. Appl. Math. 8(4), 703 to 712 (1960)) while cut_condition(m) returns true then activates the integrality constraints of the relaxed problems and solves the resulting MILP relaxation. results are stored to the _lower_solution, _lower_termination_status, _lower_primal_status, _lower_dual_status, _lower_objective_value, and _lower_feasibility. Further, lower and upper variable duals are stored _lower_lvd and _lower_uvd, respectively, for use in duality based bound tightening. If relaxation-based bounds are weaker or cutting-planes are numerically poorly ill-posed, then interval bounds are used instead. If the problem is dual feasible but the primal status is ambiguous the dual objective value is used for the lower bound to avoid numerical issues.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.mc_type-Union{Tuple{EAGO.RelaxCache{V, N, T}}, Tuple{T}, Tuple{N}, Tuple{V}} where {V, N, T<:RelaxTag}-dev-api_functions","page":"Functions","title":"EAGO.mc_type","text":"mc_type(::RelaxCache{V, N, T} where {V, N, T<:RelaxTag}\nmc_type(::NonlinearExpression{V, N, T} where {V, N, T<:RelaxTag}\nmc_type(::BufferedNonlinearFunction{V, N, T} where {V, N, T<:RelaxTag}\n\nReturns a McCormick structure of type MC{N, T<:RelaxTag}.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.mid-Union{Tuple{VariableInfo{T}}, Tuple{T}} where T<:AbstractFloat-dev-api_functions","page":"Functions","title":"EAGO.mid","text":"Return the midpoint of a variable (0.5*(upper bound + lower bound)).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.node_selection!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.node_selection!","text":"node_selection!(t::ExtensionType, m::GlobalOptimizer)\n\n\nSelect the next node in the stack to evaluate. By default, perform best-first node selection (select the node with the lowest lower bound in the stack).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.obbt!-Union{Tuple{GlobalOptimizer{R, S, Q}}, Tuple{Q}, Tuple{S}, Tuple{R}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.obbt!","text":"obbt!(m::GlobalOptimizer{R, S, Q<:ExtensionType}) -> Bool\n\n\nPerforms OBBT with filtering and greedy ordering as detailed in: Gleixner, A.M., Berthold, T., Müller, B. et al. J Glob Optim (2017) 67: 731. https://doi.org/10.1007/s10898-016-0450-4\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.objective_cut!-Tuple{GlobalOptimizer, Bool}-dev-api_functions","page":"Functions","title":"EAGO.objective_cut!","text":"objective_cut!\n\nAdd linear objective cut constraint to the m._subsolvers.relaxed_optimizer.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.optimize_hook!-Tuple{ExtensionType, Optimizer}-dev-api_functions","page":"Functions","title":"EAGO.optimize_hook!","text":"optimize_hook!(t::ExtensionType, m::Optimizer)\n\nProvide a hook for extensions to EAGO. \n\nThe user-defined extension of optimize_hook! is used in EAGO's overloading of MOI.optimize! (see EAGO.jl/src/eago_optimizer/optimize/optimize.jl). Without the optimize_hook! specified, EAGO will run initial_parse!, parse_classify_problem!, and then optimize! using the parsed problem type. The user-specified optimize_hook! should thus take the new extension and Optimizer as inputs and will execute when the user writes optimize!(model).\n\nExample\n\nHere, optimize_hook! is used to bypass EAGO's problem parsing and treat every problem using its branch-and-bound routine. This is done in this example by telling EAGO to treat the problem as a mixed integer nonconvex problem, which normally dispatches to branch-and-bound.\n\nstruct MyNewExtension <: EAGO.ExtensionType end\nimport EAGO: optimize_hook!\nfunction EAGO.optimize_hook!(t::MyNewExtension, m::Optimizer)\n initial_parse!(m)\n optimize!(EAGO.MINCVX(), m)\nend\n\nThe same functionality could be accomplished by setting the EAGOParameter field force_global_solve to be true.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.parse_classify_problem!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.parse_classify_problem!","text":"parse_classify_problem!(m::GlobalOptimizer)\n\nInterprets the type/number of constraints and the type of objective function to infer a problem type. Current possible types include:\n\nLP: Linear program; sent to optimize_lp.jl\n'MILP: Mixed integer linear program; sent tooptimize_lp.jl`\nSOCP: Second-order cone program; sent to optimize_conic.jl\nMINCVX: Mixed-integer nonconvex; sent to optimize_nonconvex.jl\n\nIf the force_global_solve parameter is set to true, parse_classify_problem! will set the problem type to MINCVX to pass the problem to optimize_nonconvex.jl.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.parse_global!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.parse_global!","text":"Basic parsing for global solutions (no extensive manipulation). By default, does nothing.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.postprocess!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.postprocess!","text":"postprocess!(t::ExtensionType, m::GlobalOptimizer)\n\n\nDefault postprocess perfoms duality-based bound tightening (Tawarmalani, M., Sahinidis, N.V.: Global optimization of mixed-integer nonlinear programs: a theoretical and computational study. Math. Progr. 99, 563–591 (2004).) up to an iteration limit set by dbbt_depth.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.preprocess!-Union{Tuple{Q}, Tuple{S}, Tuple{R}, Tuple{ExtensionType, GlobalOptimizer{R, S, Q}}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.preprocess!","text":"preprocess!(\n t::ExtensionType,\n m::GlobalOptimizer{R, S, Q<:ExtensionType}\n)\n\n\nRuns contractor methods prior to solving lower bounding problem. By default linear and quadratic contractor methods followed by interval constraint propagation then optimization-based bound tightening for a specified number of iterations while the subproblem at current node n has not been proven infeasible.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.presolve_global!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.presolve_global!","text":"presolve_global!(t::ExtensionType, m::GlobalOptimizer)\n\n\nPerform any necessary work prior to running branch-and-bound. \n\nSet subsolver configs using values in EAGOParameters;\nLoad variables, linear constraints, and empty storage space into the relaxed optimizer;\nPrepare the stack for the start of branch-and-bound;\nFill fields of the GlobalOptimizer with zeros of the proper dimensions;\nPass necessary flags from the GlobalOptimizer to the working problem.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.print_iteration!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.print_iteration!","text":"print_iteration!\n\nPrint status information based on iteration count. The header print frequency is based on the header_iterations setting, and the data print frequency is based on the output_iterations setting.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.print_node!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.print_node!","text":"print_node!\n\nPrint information about the current node. Includes node ID, lower bound, upper bound, and interval box.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.print_preamble!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.print_preamble!","text":"print_preamble!\n\nPrint noteworthy information prior to running branch-and-bound. Currently prints a note about flipping max(f) to -min(-f) internally, if a maximization problem is inputted and verbosity>=3.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.print_results!-Tuple{GlobalOptimizer, Bool}-dev-api_functions","page":"Functions","title":"EAGO.print_results!","text":"print_results!(m::GlobalOptimizer, lower_flag::Bool)\n\n\nPrint the results of a single (lower or upper) bounding problem. lower_flag=true prints information for the lower problem, lower_flag=false prints information for the upper problem.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.print_solution!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.print_solution!","text":"print_solution!\n\nPrint solution information for the B&B problem. Display node with the best solution, solution value, solution, and time spent solving subproblems. This print occurs following termination of the B&B algorithm.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.r_init!-Tuple{AbstractCacheAttribute, AbstractDirectedGraph, AbstractCache}-dev-api_functions","page":"Functions","title":"EAGO.r_init!","text":"Initializes information in cache c for each node in g that may be used in a reverse-pass of attribute t. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.reform_epigraph_min!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.reform_epigraph_min!","text":"reform_epigraph_min!(m::GlobalOptimizer)\n\n\nPerform an epigraph reformulation assuming the working_problem is a minimization problem.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.register_eago_operators!-Tuple{Model}-dev-api_functions","page":"Functions","title":"EAGO.register_eago_operators!","text":"registereagooperators!\n\nRegisters all nonstandard nonlinear terms available in EAGO in a JuMP. Uses of these is generally preferable in EAGO as the relaxations EAGO will generate will usually be tighter (speeding up convergence time). Note that this will work can be used by other nonlinear solvers (Ipopt for instance).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rel_diam-Tuple{GlobalOptimizer, Int64}-dev-api_functions","page":"Functions","title":"EAGO.rel_diam","text":"rel_diam(m::GlobalOptimizer, i::Int64) -> Float64\n\n\nReturn the relative diameter of a variable. In the case of diam(X)=Inf, rel_diam returns 0.0 to prevent \"branching\" on this variable endlessly.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.relax!-Tuple{GlobalOptimizer, EAGO.BufferedQuadraticEq, Int64, Bool}-dev-api_functions","page":"Functions","title":"EAGO.relax!","text":"relax!(\n m::GlobalOptimizer,\n f::EAGO.BufferedQuadraticEq,\n i::Int64,\n check_safe::Bool\n) -> Bool\n\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.relax!-Tuple{GlobalOptimizer, EAGO.BufferedQuadraticIneq, Int64, Bool}-dev-api_functions","page":"Functions","title":"EAGO.relax!","text":"relax!(\n m::GlobalOptimizer,\n f::EAGO.BufferedQuadraticIneq,\n k::Int64,\n check_safe::Bool\n) -> Bool\n\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.relax!-Union{Tuple{Q}, Tuple{T}, Tuple{N}, Tuple{S}, Tuple{R}, Tuple{V}, Tuple{GlobalOptimizer{R, S, Q}, EAGO.BufferedNonlinearFunction{V, N, T}, Int64, Bool}} where {V, R, S, N, T<:RelaxTag, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.relax!","text":"relax!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType},\n f::EAGO.BufferedNonlinearFunction{V, N, T<:RelaxTag},\n k::Int64,\n check_safe::Bool\n) -> Tuple{Bool, Bool}\n\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.relax!-dev-api_functions","page":"Functions","title":"EAGO.relax!","text":"relax!\n\nRelax the constraint by adding an affine constraint to the model.\n\n\n\n\n\n","category":"function"},{"location":"dev/api_functions/#EAGO.relax_all_constraints!-Tuple{ExtensionType, GlobalOptimizer, Int64}-dev-api_functions","page":"Functions","title":"EAGO.relax_all_constraints!","text":"relax_all_constraints!(\n t::ExtensionType,\n m::GlobalOptimizer,\n k::Int64\n) -> Tuple{Bool, Bool}\n\n\nA routine that adds relaxations for all nonlinear constraints and quadratic constraints corresponding to the current node to the relaxed problem. This adds an objective cut (if specified by objective_cut_on) and then sets the _new_eval_constraint flag to false indicating that an initial evaluation of the constraints has occurred. If the objective_cut_on flag is true then the _new_eval_objective flag is also set to false indicating that the objective expression was evaluated.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.relaxed_problem_status-Tuple{MathOptInterface.TerminationStatusCode, MathOptInterface.ResultStatusCode, MathOptInterface.ResultStatusCode}-dev-api_functions","page":"Functions","title":"EAGO.relaxed_problem_status","text":"relaxed_problem_status(t, p, d)\n\n\nTake an MOI.TerminationStatusCode and two MOI.ResultStatusCodes (one each for the primal and dual status) and return a RelaxResultStatus. Returns RRS_OPTIMAL if the codes prove that the subproblem solution was solved to global optimality. Returns RRS_INFEASIBLE if the codes prove that the subproblem solution is infeasible. Returns RRS_DUAL_FEASIBLE if subproblem solution is not optimal and not proven infeasible, but the dual status is MOI.FEASIBLE_POINT. Returns RRS_INVALID otherwise.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.repeat_check-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.repeat_check","text":"repeat_check(t::ExtensionType, m::GlobalOptimizer) -> Bool\n\n\nCheck to see if current node should be reprocessed. Without any custom extension, return false by default.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Constant, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a constant v at index k in cache c associated with graph g using information at index k taken from the parents of k.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Expression, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a expressions v at index k in cache c associated with graph g using information at index k taken from the parents of k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Parameter, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a parameters v at index k in cache c associated with graph g using information at index k taken from the parents of k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Subexpression, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a subexpressions v at index k in cache c associated with graph g using information at index k taken from the parents of k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop!-Tuple{AbstractCacheAttribute, Variable, AbstractDirectedGraph, AbstractCache, Int64}-dev-api_functions","page":"Functions","title":"EAGO.rprop!","text":"Populates information associated with attribute t for a variable v at index k in cache c associated with graph g using information at index k taken from the parents of k. \n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop!-Union{Tuple{T}, Tuple{EAGO.RelaxInterval, Val{EAGO.MULT}, EAGO.DirectedTree, EAGO.IntervalCache{T}, Int64}} where T<:Real-dev-api_functions","page":"Functions","title":"EAGO.rprop!","text":"rprop!\n\nUpdates storage tapes with reverse evalution of node representing n = *(x,y,z...) which updates x, y, z and so on.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop!-Union{Tuple{T}, Tuple{EAGO.RelaxInterval, Val{EAGO.PLUS}, EAGO.DirectedTree, EAGO.IntervalCache{T}, Int64}} where T<:Real-dev-api_functions","page":"Functions","title":"EAGO.rprop!","text":"rprop!\n\nUpdates storage tapes with reverse evalution of node representing n = +(x,y,z...) which updates x, y, z and so on.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop_2!-Union{Tuple{T}, Tuple{N}, Tuple{V}, Tuple{EAGO.Relax, Val{EAGO.MULT}, EAGO.DirectedTree, EAGO.RelaxCache{V, N, T}, Int64}} where {V, N, T<:RelaxTag}-dev-api_functions","page":"Functions","title":"EAGO.rprop_2!","text":"rprop_2!\n\nUpdates storage tapes with reverse evalution of node representing n = x * y which updates x and y.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop_2!-Union{Tuple{T}, Tuple{N}, Tuple{V}, Tuple{EAGO.Relax, Val{EAGO.PLUS}, EAGO.DirectedTree, EAGO.RelaxCache{V, N, T}, Any}} where {V, N, T<:RelaxTag}-dev-api_functions","page":"Functions","title":"EAGO.rprop_2!","text":"rprop_2!\n\nUpdates storage tapes with reverse evalution of node representing n = x + y which updates x and y.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop_n!-Union{Tuple{T}, Tuple{N}, Tuple{V}, Tuple{EAGO.Relax, Val{EAGO.MULT}, EAGO.DirectedTree, EAGO.RelaxCache{V, N, T}, Int64}} where {V, N, T<:RelaxTag}-dev-api_functions","page":"Functions","title":"EAGO.rprop_n!","text":"rprop_n!\n\nUpdates storage tapes with reverse evalution of node representing n = *(x,y,z...) which updates x, y, z and so on.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.rprop_n!-Union{Tuple{T}, Tuple{N}, Tuple{V}, Tuple{EAGO.Relax, Val{EAGO.PLUS}, EAGO.DirectedTree, EAGO.RelaxCache{V, N, T}, Int64}} where {V, N, T<:RelaxTag}-dev-api_functions","page":"Functions","title":"EAGO.rprop_n!","text":"rprop_n!\n\nUpdates storage tapes with reverse evalution of node representing n = +(x,y,z...) which updates x, y, z and so on.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.same_box-Tuple{NodeBB, NodeBB, Float64}-dev-api_functions","page":"Functions","title":"EAGO.same_box","text":"same_box(x::NodeBB, y::NodeBB, r::Float64) -> Bool\n\n\nCheck that node x and y have equal domains within an absolute tolerance of r.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.select_branch_point-Tuple{ExtensionType, GlobalOptimizer, Any}-dev-api_functions","page":"Functions","title":"EAGO.select_branch_point","text":"select_branch_point(\n t::ExtensionType,\n m::GlobalOptimizer,\n i\n) -> Float64\n\n\nSelect a point xb within the domain of the ith branching variable. By default, this point is a convex combination of the solution to the relaxation and the midpoint of the node (branch_cvx_factor*xmid + (1-branch_cvx_factor)*xsol). If the solution lies within branch_offset of a bound, then the branch point is moved to a distance of branch_offset from that bound.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.select_branch_variable-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.select_branch_variable","text":"select_branch_variable(\n t::ExtensionType,\n m::GlobalOptimizer\n) -> Any\n\n\nChoose a variable to branch on. A maximum relative width branching rule is used by default.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_constraint_propagation_fbbt!-Union{Tuple{GlobalOptimizer{R, S, Q}}, Tuple{Q}, Tuple{S}, Tuple{R}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.set_constraint_propagation_fbbt!","text":"set_constraint_propagation_fbbt!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType}\n) -> Bool\n\n\nPerforms bound tightening based on forward/reverse interval and/or McCormick passes. This routine resets the current node with new interval bounds.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_default_config!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.set_default_config!","text":"set_default_config!\n\nConfigures subsolver tolerances based on tolerance parameters provided to EAGO (provided that a specialized subsolver configuration routine has been provided and m.user_solver_config = false).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_dual!-Union{Tuple{GlobalOptimizer{R, S, Q}}, Tuple{Q}, Tuple{S}, Tuple{R}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.set_dual!","text":"set_dual!(m)\n\n\nRetrieves the lower and upper duals for variable bounds from the relaxed_optimizer and sets the appropriate values in the _lower_lvd and _lower_uvd storage fields.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_first_relax_point!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.set_first_relax_point!","text":"set_first_relax_point!(m::GlobalOptimizer)\n\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_global_lower_bound!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.set_global_lower_bound!","text":"set_global_lower_bound!(m::GlobalOptimizer)\n\n\nIf the previous best-known global lower bound is lower than the lowest lower bound in the stack, set the global lower bound equal to the lowest lower bound in the stack.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_node!-Tuple{Evaluator, NodeBB}-dev-api_functions","page":"Functions","title":"EAGO.set_node!","text":"set_node!\n\nSets the current node in the Evaluator structure.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_reference_point!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.set_reference_point!","text":"set_reference_point!(m::GlobalOptimizer)\n\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_result_status!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.set_result_status!","text":"set_result_status!(m::GlobalOptimizer)\n\n\nConvert EAGO's ending status code into an MOI.ResultStatusCode.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.set_termination_status!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.set_termination_status!","text":"set_termination_status!(m::GlobalOptimizer)\n\n\nConvert EAGO's ending status code into an MOI.TerminationStatusCode.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.single_storage!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.single_storage!","text":"single_storage!(t::ExtensionType, m::GlobalOptimizer)\n\n\nStore the current node to the stack, without branching, after updating lower/upper bounds.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.sip_bnd!-Union{Tuple{S}, Tuple{A}, Tuple{ExtensionType, A, S, SIPSubResult, SIPResult, SIPProblem, SIPCallback}} where {A<:AbstractSIPAlgo, S<:AbstractSubproblemType}-dev-api_functions","page":"Functions","title":"EAGO.sip_bnd!","text":"sip_bnd!\n\nSolves the bounding problem for the ith-SIP used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_bnd!(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, ..., i, tol).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.sip_llp!-Union{Tuple{S}, Tuple{A}, Tuple{EAGO.DefaultExt, A, S, SIPResult, SIPSubResult, SIPProblem, SIPCallback, Int64}, Tuple{EAGO.DefaultExt, A, S, SIPResult, SIPSubResult, SIPProblem, SIPCallback, Int64, Float64}} where {A<:AbstractSIPAlgo, S<:AbstractSubproblemType}-dev-api_functions","page":"Functions","title":"EAGO.sip_llp!","text":"sip_llp!\n\nSolves the lower level problem for the ith-SIP used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_llp!(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, ..., i, tol).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.sip_res!-Union{Tuple{A}, Tuple{ExtensionType, A, SIPSubResult, SIPResult, SIPProblem, SIPCallback}} where A<:AbstractSIPAlgo-dev-api_functions","page":"Functions","title":"EAGO.sip_res!","text":"sip_res!\n\nSolves the restriction problem for extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_res!(t::ExtensionType, a::AbstractSIPAlgo, ...).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.sip_solve-Union{Tuple{T}, Tuple{T, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Function, Vector}} where T<:AbstractSIPAlgo-dev-api_functions","page":"Functions","title":"EAGO.sip_solve","text":"sip_solve\n\nSolve an SIP with decision variable bounds x_l to x_u, uncertain variable bounds p_l to p_u, an objective function of f, and gSIP seminfiniite constraint(s).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.solve_local_nlp!-Union{Tuple{GlobalOptimizer{R, S, Q}}, Tuple{Q}, Tuple{S}, Tuple{R}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.solve_local_nlp!","text":"Constructs and solves the problem locally on node y updated the upper solution informaton in the optimizer.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.store_candidate_solution!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.store_candidate_solution!","text":"store_candidate_solution!(m::GlobalOptimizer)\n\n\nIf the most recent upper problem returned a feasible result, and the upper objective value is less than the previous best-known global upper bound, set the most recent upper problem result to be the new global upper bound. Update the _feasible_solution_found, _solution_node, _global_upper_bound, and _continuous_solution fields of the GlobalOptimizer accordingly.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.stored_adjusted_upper_bound!-Tuple{GlobalOptimizer, Float64}-dev-api_functions","page":"Functions","title":"EAGO.stored_adjusted_upper_bound!","text":"stored_adjusted_upper_bound!(d, v)\n\n\nShifts the resulting local nlp objective value f* by (1.0 + relative_tolerance/100.0)*f* + absolute_tolerance/100.0. This assumes that the local solvers relative tolerance and absolute tolerance is significantly lower than the global tolerance (local problem is minimum).\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.termination_check-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.termination_check","text":"termination_check(m::GlobalOptimizer)\ntermination_check(t::ExtensionType, m::GlobalOptimizer) -> Bool\n\nCheck for termination of the branch-and-bound algorithm.\n\nIf only the GlobalOptimizer is given as an argument, termination_check dispatches to the other form using the ExtensionType given in the SubSolvers. If there is no user-defined extension, then by default, this will check for satisfaction of absolute or relative tolerances, solution infeasibility, and other specified limits. Returns true if any conditions are met and branch-and-bound should end, and false otherwise.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.trivial_filtering!-Union{Tuple{Q}, Tuple{S}, Tuple{R}, Tuple{GlobalOptimizer{R, S, Q}, NodeBB}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.trivial_filtering!","text":"trivial_filtering!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType},\n n::NodeBB\n)\n\n\nExcludes OBBT on variable indices that are tight for the solution of the relaxation.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.unbounded_check!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.unbounded_check!","text":"unbounded_check!(m::GlobalOptimizer) -> Union{Nothing, Bool}\n\n\nCheck the optimization problem for unbounded branching variables, which would interfere with EAGO's branch-and-bound routine since there are no well-defined branching rules for cases where the interval bounds contain -Inf or Inf. If any branching variables are missing bounds, add the missing bound at +/- 1E10 and warn the user.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.unpack_fbbt_buffer!-Tuple{GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.unpack_fbbt_buffer!","text":"unpack_fbbt_buffer!(m::GlobalOptimizer)\n\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.unpack_global_solution!-Union{Tuple{Optimizer{R, S, Q}}, Tuple{Q}, Tuple{S}, Tuple{R}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.unpack_global_solution!","text":"unpack_global_solution!(\n m::Optimizer{R, S, Q<:ExtensionType}\n)\n\n\nIf global optimization was performed, much of the work happened within the _global_optimizer::GlobalOptimizer. The unpack_global_solution! function extracts results from the GlobalOptimizer and puts them in the correct fields of the Optimizer.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.unsafe_check_fill!-Union{Tuple{T}, Tuple{Any, Vector{T}, T, Int64}} where T-dev-api_functions","page":"Functions","title":"EAGO.unsafe_check_fill!","text":"unsafe_check_fill!(f, y::Array{T, 1}, x, n::Int64)\n\n\nPerforms map!(f, y, x) in an unsafe manner if y[i] is true, else no-op. Assumes n == length(x) == length(y). About 2x faster for small arrays (n < 1000).\n\n[Unused]\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.update_relaxed_problem_box!-Union{Tuple{GlobalOptimizer{R, S, Q}}, Tuple{Q}, Tuple{S}, Tuple{R}} where {R, S, Q<:ExtensionType}-dev-api_functions","page":"Functions","title":"EAGO.update_relaxed_problem_box!","text":"update_relaxed_problem_box!(m)\n\n\nUpdate the relaxed constraint by setting the constraint set of v == x* , xL_i <= x_i, and x_i <= xU_i for each such constraint added to the relaxed optimizer. Resets integral valued constraints to either EqualTo or Interval constraints.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.upper_problem!-Tuple{ExtensionType, GlobalOptimizer}-dev-api_functions","page":"Functions","title":"EAGO.upper_problem!","text":"upper_problem!(t::ExtensionType, m::GlobalOptimizer)\n\n\nDefault upper bounding problem which simply calls solve_local_nlp! to solve the NLP locally.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.variable_dbbt!-Tuple{NodeBB, Vector{Float64}, Vector{Float64}, Float64, Float64, Int64}-dev-api_functions","page":"Functions","title":"EAGO.variable_dbbt!","text":"variable_dbbt!(\n n::NodeBB,\n mult_lo::Vector{Float64},\n mult_hi::Vector{Float64},\n LBD::Float64,\n UBD::Float64,\n nx::Int64\n)\n\n\nTighten the bounds of the _current_node using the current global upper bound and the duality information obtained from the relaxation.\n\n\n\n\n\n","category":"method"},{"location":"dev/api_functions/#EAGO.variable_load_parse!-Union{Tuple{T}, Tuple{Optimizer, Type{MathOptInterface.VariableIndex}, Type{T}}} where T-dev-api_functions","page":"Functions","title":"EAGO.variable_load_parse!","text":"variable_load_parse!\n\nParse constraint information of a given constraint type to fill in related variable information.\n\n\n\n\n\n","category":"method"},{"location":"ref/#References","page":"References","title":"References","text":"","category":"section"},{"location":"ref/#Branch-and-Bound","page":"References","title":"Branch and Bound","text":"","category":"section"},{"location":"ref/","page":"References","title":"References","text":"Floudas, CA (2013). Deterministic global optimization: theory, methods and applications. Vol. 37. Springer Science & Business Media.\nHorst, R, Tuy, H (2013). Global optimization: Deterministic approaches. Springer Science & Business Media.","category":"page"},{"location":"ref/#Parametric-Interval-Techniques","page":"References","title":"Parametric Interval Techniques","text":"","category":"section"},{"location":"ref/","page":"References","title":"References","text":"Hansen ER, Walster GW (2004). Global Optimization Using Interval Analysis. Marcel Dekker, New York, second edition.\nKrawczyk R (1969). Newton-algorithmen zur bestimmung con nullstellen mit fehler-schranken. Computing, 4:187–201.\nKrawczyk R (1984). Interval iterations for including a set of solutions. Computing, 32:13–31.\nMiranda C (1940). Un’osservatione su un teorema di brower. Boll. Un. Mat. Ital., 3:5–7.\nNeumaier A (1990). Interval Methods for Systems of Equations. Cambridge University Press, Cambridge.\nMoore RE (1977). A test for existence of solutions to nonlinear systems. SIAM Journal on Numerical Analysis, 14(4):611–615.","category":"page"},{"location":"ref/#Domain-Reduction","page":"References","title":"Domain Reduction","text":"","category":"section"},{"location":"ref/","page":"References","title":"References","text":"Benhamou F, & Older WJ (1997). Applying interval arithmetic to real, integer, and boolean constraints. The Journal of Logic Programming, 32, 1–24.\nCaprara A, & Locatelli M (2010). Global optimization problems and domain reduction strategies. Mathematical Programming, 125, 123–137.\nGleixner AM, Berthold T, Müller B, & Weltge S (2016). Three enhancements for optimization-based bound tightening. ZIB Report, 15–16.\nRyoo HS, & Sahinidis NV (1996). A branch-and-reduce approach to global optimization. Journal of Global Optimization, 8, 107–139.\nSchichl H, & Neumaier A (2005). Interval analysis on directed acyclic graphs for global optimization. Journal of Global Optimization, 33, 541–562.\nTawarmalani, M, & Sahinidis, NV (2005). A polyhedral branch-and-cut approach to global optimization. Mathematical Programming, 103, 225–249.\nVu, X, Schichl, H, & Sam-Haroud, D (2009). Interval propagation and search on directed acyclic graphs for numerical constraint solving. Journal of Global Optimization, 45, 499–531.","category":"page"},{"location":"ref/#Generalized-McCormick-Relaxations","page":"References","title":"Generalized McCormick Relaxations","text":"","category":"section"},{"location":"ref/","page":"References","title":"References","text":"Chachuat, B (2014). MC++: a toolkit for bounding factorable functions, v1.0. Retrieved 2 July 2014 https://projects.coin-or.org/MCpp\nMitsos A, Chachuat B, and Barton PI. (2009). McCormick-based relaxations of algorithms. SIAM Journal on Optimization, 20(2):573–601.\nMcCormick, GP (1976).. Computability of global solutions to factorable nonconvex programs: Part I-Convex underestimating problems. Mathematical Programming, 10:147–175.\nMcCormick, GP (1983). Nonlinear programming: Theory, Algorithms, and Applications. Wiley, New York.\nScott JK, Stuber MD, and Barton PI. (2011). Generalized McCormick relaxations. Journal of Global Optimization, 51(4):569–606.\nStuber MD, Scott JK, Barton PI (2015). Convex and concave relaxations of implicit functions. Optim. Methods Softw. 30(3), 424–460\nTsoukalas A and Mitsos A (2014). Multivariate McCormick Relaxations. Journal of Global Optimization, 59:633–662.\nKhan KA, Watson HAJ, Barton PI (2017). Differentiable McCormick relaxations. Journal of Global Optimization, 67(4):687-729.\nWechsung A, Scott JK, Watson HAJ, and Barton PI. (2015). Reverse propagation of McCormick relaxations. Journal of Global Optimization 63(1):1-36.","category":"page"},{"location":"ref/#Semi-Infinite-Programming","page":"References","title":"Semi-Infinite Programming","text":"","category":"section"},{"location":"ref/","page":"References","title":"References","text":"Mitsos A (2009). Global optimization of semi-infinite programs via restriction of the right-hand side. Optimization, 60(10-11):1291-1308.\nStuber MD and Barton PI (2015). Semi-Infinite Optimization With Implicit Functions. Industrial & Engineering Chemistry Research, 54:307-317, 2015.","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"(Image: logo)","category":"page"},{"location":"#EAGO-Easy-Advanced-Global-Optimization-in-Julia","page":"Introduction","title":"EAGO - Easy Advanced Global Optimization in Julia","text":"","category":"section"},{"location":"","page":"Introduction","title":"Introduction","text":"A development environment for robust and global optimization in Julia.","category":"page"},{"location":"#Authors","page":"Introduction","title":"Authors","text":"","category":"section"},{"location":"","page":"Introduction","title":"Introduction","text":"Matthew Wilhelm, Department of Chemical and Biomolecular Engineering, University of Connecticut (UConn)\nCurrent Position: Alexion Pharmaceuticals\nRobert Gottlieb, Department of Chemical and Biomolecular Engineering, University of Connecticut (UConn)\nDimitri Alston, Department of Chemical and Biomolecular Engineering, University of Connecticut (UConn)\nMatthew Stuber, Associate Professor, University of Connecticut (UConn)","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"If you would like to contribute, contact us.","category":"page"},{"location":"#Overview","page":"Introduction","title":"Overview","text":"","category":"section"},{"location":"","page":"Introduction","title":"Introduction","text":"EAGO is a global and robust optimization platform based on McCormick relaxations. It contains the first widely accessible global optimization routine based on generalized McCormick relaxations. With the exception of calls to local solvers and linear algebra routines, EAGO is written entirely in native Julia. The solver is flexibly arranged so the end user can easily customize low-level routines.","category":"page"},{"location":"#Installing-EAGO","page":"Introduction","title":"Installing EAGO","text":"","category":"section"},{"location":"","page":"Introduction","title":"Introduction","text":"EAGO is a registered Julia package and it can be installed using the Julia package manager. From the Julia REPL, type ] to enter the Package manager (Pkg) mode and run the following command:","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"pkg> add EAGO","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"Currently, EAGO is compatible with version 1.12 of JuMP. This allows a replication of some of the internal features shared by EAGO and JuMP's automatic differentiation scheme, e.g., generation of Wengert Tapes, passing evaluators between JuMP and EAGO, etc.","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"pkg> add JuMP","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"EAGO v0.8.1 is the current tagged version and requires Julia 1.6+ for full functionality (however Julia 1.0+ versions support partial functionality). Use with version 1.8 is recommended as the majority of in-house testing has occurred using this version of Julia. The user is directed to the High-Performance Configuration for instructions on how to install a high performance version of EAGO (rather than the basic entirely open-source version). If any issues are encountered when loading EAGO (or when using it), please submit an issue using the GitHub issue tracker.","category":"page"},{"location":"#Examples","page":"Introduction","title":"Examples","text":"","category":"section"},{"location":"","page":"Introduction","title":"Introduction","text":"Several examples are provided within this documentation, but additional examples are provided in the form of Jupyter Notebooks at EAGO-notebooks which can be run using IJulia. To add IJulia, run the command:","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"pkg> add IJulia","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"Then launch the Jupyter Notebook using the following command from the Julia terminal:","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"julia> using IJulia; notebook()","category":"page"},{"location":"","page":"Introduction","title":"Introduction","text":"And then simply navigate to the example directory and run the example of most interest.","category":"page"},{"location":"optimizer/domain_reduction/#Domain-Reduction","page":"Domain Reduction","title":"Domain Reduction","text":"","category":"section"},{"location":"optimizer/domain_reduction/#Duality-Based-Bound-Tightening","page":"Domain Reduction","title":"Duality-Based Bound Tightening","text":"","category":"section"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"Variable bound tightening based on the duality multipliers are supported.","category":"page"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"variable_dbbt!","category":"page"},{"location":"optimizer/domain_reduction/#EAGO.variable_dbbt!","page":"Domain Reduction","title":"EAGO.variable_dbbt!","text":"variable_dbbt!(\n n::NodeBB,\n mult_lo::Vector{Float64},\n mult_hi::Vector{Float64},\n LBD::Float64,\n UBD::Float64,\n nx::Int64\n)\n\n\nTighten the bounds of the _current_node using the current global upper bound and the duality information obtained from the relaxation.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/domain_reduction/#Special-Forms","page":"Domain Reduction","title":"Special Forms","text":"","category":"section"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"Bound tightening for linear forms, univariate quadratic forms, and bivariate quadratic forms are also supported.","category":"page"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"EAGO.fbbt!","category":"page"},{"location":"optimizer/domain_reduction/#EAGO.fbbt!","page":"Domain Reduction","title":"EAGO.fbbt!","text":"fbbt!(m::GlobalOptimizer, f::T)\n\nPerforms feasibility-based bound tightening on a back-end constraint and returns true if it is feasible or false if it is infeasible.\n\nOptions for T (all are subtypes of AbstractEAGOConstraint):\n\nAffineFunctionIneq\nAffineFunctionEq\n\n\n\n\n\n","category":"function"},{"location":"optimizer/domain_reduction/#Constraint-Propagation","page":"Domain Reduction","title":"Constraint Propagation","text":"","category":"section"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"EAGO contains a constraint propagation architecture that supported forward and reverse evaluation of set-valued functions on the directed acyclic graph. The interval contractor and reverse McCormick relaxation-based contractors are currently available.","category":"page"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"EAGO.set_constraint_propagation_fbbt!","category":"page"},{"location":"optimizer/domain_reduction/#EAGO.set_constraint_propagation_fbbt!","page":"Domain Reduction","title":"EAGO.set_constraint_propagation_fbbt!","text":"set_constraint_propagation_fbbt!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType}\n) -> Bool\n\n\nPerforms bound tightening based on forward/reverse interval and/or McCormick passes. This routine resets the current node with new interval bounds.\n\n\n\n\n\n","category":"function"},{"location":"optimizer/domain_reduction/#Optimization-Based-Bound-Tightening","page":"Domain Reduction","title":"Optimization-Based Bound Tightening","text":"","category":"section"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"EAGO makes use of an optimization-based bound tightening scheme using filtering and greedy ordering as detailed in [1].","category":"page"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"EAGO.obbt!\nEAGO.trivial_filtering!(m::GlobalOptimizer{R,S,Q}, n::NodeBB) where {R,S,Q<:ExtensionType}\nEAGO.aggressive_filtering!(m::GlobalOptimizer{R,S,Q}, n::NodeBB) where {R,S,Q<:ExtensionType}\nEAGO.bool_indx_diff!(z::Vector{Bool},x::Vector{Bool}, y::Vector{Bool})","category":"page"},{"location":"optimizer/domain_reduction/#EAGO.obbt!","page":"Domain Reduction","title":"EAGO.obbt!","text":"obbt!(m::GlobalOptimizer{R, S, Q<:ExtensionType}) -> Bool\n\n\nPerforms OBBT with filtering and greedy ordering as detailed in: Gleixner, A.M., Berthold, T., Müller, B. et al. J Glob Optim (2017) 67: 731. https://doi.org/10.1007/s10898-016-0450-4\n\n\n\n\n\n","category":"function"},{"location":"optimizer/domain_reduction/#EAGO.trivial_filtering!-Union{Tuple{Q}, Tuple{S}, Tuple{R}, Tuple{GlobalOptimizer{R, S, Q}, NodeBB}} where {R, S, Q<:ExtensionType}","page":"Domain Reduction","title":"EAGO.trivial_filtering!","text":"trivial_filtering!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType},\n n::NodeBB\n)\n\n\nExcludes OBBT on variable indices that are tight for the solution of the relaxation.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/domain_reduction/#EAGO.aggressive_filtering!-Union{Tuple{Q}, Tuple{S}, Tuple{R}, Tuple{GlobalOptimizer{R, S, Q}, NodeBB}} where {R, S, Q<:ExtensionType}","page":"Domain Reduction","title":"EAGO.aggressive_filtering!","text":"aggressive_filtering!(\n m::GlobalOptimizer{R, S, Q<:ExtensionType},\n n::NodeBB\n) -> Bool\n\n\nExcludes OBBT on variable indices after a search in a filtering direction.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/domain_reduction/#EAGO.bool_indx_diff!-Tuple{Vector{Bool}, Vector{Bool}, Vector{Bool}}","page":"Domain Reduction","title":"EAGO.bool_indx_diff!","text":"bool_indx_diff!(\n z::Vector{Bool},\n x::Vector{Bool},\n y::Vector{Bool}\n) -> Vector{Bool}\n\n\nUtility function used to set vector of booleans z to x & ~y. Avoids the generation of conversion of the BitArray created by broadcasting logical operators.\n\n\n\n\n\n","category":"method"},{"location":"optimizer/domain_reduction/#References","page":"Domain Reduction","title":"References","text":"","category":"section"},{"location":"optimizer/domain_reduction/","page":"Domain Reduction","title":"Domain Reduction","text":"Gleixner, A.M., Berthold, T., Müller, B. et al. J Glob Optim (2017) 67: 731. https://doi.org/10.1007/s10898-016-0450-4","category":"page"}] } diff --git a/dev/semiinfinite/semiinfinite/index.html b/dev/semiinfinite/semiinfinite/index.html index e8c47736..5556fb89 100644 --- a/dev/semiinfinite/semiinfinite/index.html +++ b/dev/semiinfinite/semiinfinite/index.html @@ -20,4 +20,4 @@ p_l = Float64[0.0] p_u = Float64[1.0] -sip_result = sip_solve(SIPRes(), x_l, x_u, p_l, p_u, f, Any[gSIP], res_sip_absolute_tolerance = 1E-3);

Semi-Infinite Solver

EAGO.SIPProblem — Type
  SIPProblem

Structure storing problem information for the solution routine.

source
EAGO.SIPResult — Type
SIPResult

Structure storing the results of the SIPRes algorithm.

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.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.get_sip_optimizer — Function
get_sip_optimizer

Specifices the optimizer to be used in extension t::EAGO.ExtensionType with algorithm alg::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command get_sip_optimizer(t::ExtensionType, alg::AbstractSIPAlgo, s::AbstractSubproblemType).

source
EAGO.build_model — Function
build_model

Create the model and variables used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command build_model(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, p::SIPProblem).

source
EAGO.sip_llp! — Function
sip_llp!

Solves the lower level problem for the ith-SIP used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_llp!(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, ..., i, tol).

source
EAGO.sip_bnd! — Function
sip_bnd!

Solves the bounding problem for the ith-SIP used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_bnd!(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, ..., i, tol).

source
EAGO.sip_res! — Function
sip_res!

Solves the restriction problem for extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_res!(t::ExtensionType, a::AbstractSIPAlgo, ...).

source
EAGO.sip_solve — Function
sip_solve

Solve an SIP with decision variable bounds x_l to x_u, uncertain variable bounds p_l to p_u, an objective function of f, and gSIP seminfiniite constraint(s).

source

References

  1. Mitsos A (2009). Global optimization of semi-infinite programs via restriction of the right-hand side. Optimization, 60(10-11):1291-1308.
  2. 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.
+sip_result = sip_solve(SIPRes(), x_l, x_u, p_l, p_u, f, Any[gSIP], res_sip_absolute_tolerance = 1E-3);

Semi-Infinite Solver

EAGO.SIPProblem — Type
  SIPProblem

Structure storing problem information for the solution routine.

source
EAGO.SIPResult — Type
SIPResult

Structure storing the results of the SIPRes algorithm.

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.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.get_sip_optimizer — Function
get_sip_optimizer

Specifices the optimizer to be used in extension t::EAGO.ExtensionType with algorithm alg::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command get_sip_optimizer(t::ExtensionType, alg::AbstractSIPAlgo, s::AbstractSubproblemType).

source
EAGO.build_model — Function
build_model

Create the model and variables used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command build_model(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, p::SIPProblem).

source
EAGO.sip_llp! — Function
sip_llp!

Solves the lower level problem for the ith-SIP used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_llp!(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, ..., i, tol).

source
EAGO.sip_bnd! — Function
sip_bnd!

Solves the bounding problem for the ith-SIP used with extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_bnd!(t::ExtensionType, a::AbstractSIPAlgo, s::AbstractSubproblemType, ..., i, tol).

source
EAGO.sip_res! — Function
sip_res!

Solves the restriction problem for extension t::EAGO.ExtensionType in algorithm a::AbstractSIPAlgo in subproblem s::AbstractSubproblemType via the command sip_res!(t::ExtensionType, a::AbstractSIPAlgo, ...).

source
EAGO.sip_solve — Function
sip_solve

Solve an SIP with decision variable bounds x_l to x_u, uncertain variable bounds p_l to p_u, an objective function of f, and gSIP seminfiniite constraint(s).

source

References

  1. Mitsos A (2009). Global optimization of semi-infinite programs via restriction of the right-hand side. Optimization, 60(10-11):1291-1308.
  2. 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.