Results

A technical manual for querying optimized InfiniteOpt models. See the respective guide for more information.

Statuses

JuMP.termination_statusMethod
JuMP.termination_status(model::InfiniteModel)

Extend JuMP.termination_status for InfiniteModels in accordance with that reported by its transformation backend. Errors if such a query is not supported or if the transformation backend hasn't been solved.

source
JuMP.raw_statusMethod
JuMP.raw_status(model::InfiniteModel)

Extend JuMP.raw_status for InfiniteModels in accordance with that reported by its transformation backend. Errors if such a query is not supported or if the transformation backend hasn't been solved.

source
JuMP.primal_statusMethod
JuMP.primal_status(model::InfiniteModel; result::Int = 1)

Extend JuMP.primal_status for InfiniteModels in accordance with that reported by its transformation backend. Errors if such a query is not supported or if the transformation backend hasn't be solved. Accepts keyword result to access the solution index of interest (if the solver/backend supports multiple solutions).

source
JuMP.dual_statusMethod
JuMP.dual_status(model::InfiniteModel; result::Int = 1)

Extend JuMP.dual_status for InfiniteModels in accordance with that reported by its transformation backend. Errors if such a query is not supported or if the transformation backend hasn't be solved. Accepts keyword result to access the solution index of interest (if the solver/backend supports multiple solutions).

source
JuMP.is_solved_and_feasibleMethod
JuMP.is_solved_and_feasible(
    model::InfiniteModel;
    [dual::Bool = false,
    allow_local::Bool = true,
    allow_almost::Bool = false,
    result::Int = 1]
    )::Bool

Extend JuMP.is_solved_and_feasible) for model. See the JuMP docs details. For new transformation backend types, this relies on JuMP.termination_status, JuMP.primal_status, and JuMP.dual_status.

source

General

JuMP.solve_timeMethod
JuMP.solve_time(model::InfiniteModel)

Extend JuMP.solve_time for InfiniteModels in accordance with that reported by its transformation backend. Errors if such a query is not supported or if the transformation backend hasn't been solved.

source
JuMP.relative_gapMethod
JuMP.relative_gap(model::InfiniteModel)

Extend JuMP.relative_gap for InfiniteModels in accordance with that reported by its transformation backend. Errors if such a query is not supported or if the transformation backend hasn't been solved.

source
JuMP.simplex_iterationsMethod
JuMP.simplex_iterations(model::InfiniteModel)

Extend JuMP.simplex_iterations for InfiniteModels in accordance with that reported by its transformation backend. Errors if such a query is not supported or if the transformation backend hasn't been solved.

source
JuMP.barrier_iterationsMethod
JuMP.barrier_iterations(model::InfiniteModel)

Extend JuMP.barrier_iterations for InfiniteModels in accordance with that reported by its transformation backend. Errors if such a query is not supported or if the transformation backend hasn't been solved.

source
JuMP.node_countMethod
JuMP.node_count(model::InfiniteModel)

Extend JuMP.node_count for InfiniteModels in accordance with that reported by its transformation backend. Errors if such a query is not supported or if the transformation backend hasn't been solved.

source
JuMP.result_countMethod
JuMP.result_count(model::InfiniteModel)

Extend JuMP.result_count for InfiniteModels in accordance with that reported by its transformation backend. Errors if such a query is not supported or if the transformation backend hasn't been solved.

source

Objective

JuMP.objective_boundMethod
JuMP.objective_bound(model::InfiniteModel)

Extend JuMP.objective_bound for InfiniteModels in accordance with that reported by its transformation backend. Errors if such a query is not supported or if the transformation backend hasn't been solved.

source
JuMP.objective_valueMethod
JuMP.objective_value(model::InfiniteModel; result::Int = 1)

Extend JuMP.objective_value for InfiniteModels in accordance with that reported by its transformation backend. Errors if such a query is not supported or if the transformation backend hasn't be solved. Accepts keyword result to access the solution index of interest (if the solver/backend supports multiple solutions).

source
JuMP.dual_objective_valueMethod
JuMP.dual_objective_value(model::InfiniteModel; result::Int = 1)

Extend JuMP.dual_objective_value for InfiniteModels in accordance with that reported by its transformation backend. Errors if such a query is not supported or if the transformation backend hasn't be solved. Accepts keyword result to access the solution index of interest (if the solver/backend supports multiple solutions).

source

Variables

JuMP.has_valuesMethod
JuMP.has_values(model::InfiniteModel; result::Int = 1)

Extend JuMP.has_values for InfiniteModels in accordance with that reported by its transformation backend. Errors if such a query is not supported or if the transformation backend hasn't be solved. Accepts keyword result to access the solution index of interest (if the solver/backend supports multiple solutions).

source
JuMP.valueMethod
JuMP.value(vref::GeneralVariableRef; [kwargs...])

Extend JuMP.value to return the value(s) of vref in accordance with its reformulation variable(s) stored in the transformation backend. Use JuMP.has_values to check whether a result exists before checking the values.

Thw keyword arguments kwargs depend on the transformation backend that is being used. The default backend TranscriptionOpt uses the keyword arguments:

  • result::Int = 1: indexes the solution result to be queried
  • label::Type{<:AbstractSupportLabel} = PublicLabel: the label of supports to be returned

By default only the values associated with public supports (i.e., PublicLabels) are returned, the full set can be accessed via label = All. Where possible, all the values are returned as an n-dimensional array where each dimension is determined by the each independent group of infinite parameters they depend on.

To provide context for the values, it may be helpful to also query the variable's parameter_refs and supports which will have a one-to-one correspondence with the value(s). It may also be helpful to query via transformation_variable to retrieve the variables(s) that these values are based on. These functions should all be called with the same keyword arguments for consistency.

For extensions, this only works if transformation_variable has been extended correctly and/or map_value has been extended for variables.

Example

julia> value(z)
42.0
source
JuMP.reduced_costMethod
JuMP.reduced_cost(ref::GeneralVariableRef; [kwargs...])

Extend JuMP.reduced_cost for refs in InfiniteModel. The exact format of output will depend on the transformation backend that is being used.

Thw keyword arguments kwargs depend on the transformation backend that is being used. The default backend TranscriptionOpt uses the keyword arguments:

  • label::Type{<:AbstractSupportLabel} = PublicLabel: the label of supports to be returned

By default only the values associated with public supports (i.e., PublicLabels) are returned, the full set can be accessed via label = All. Where possible, all the values of infinite objects are returned as an n-dimensional array where each dimension is determined by the each independent group of infinite parameters they depend on.

To provide context for the values, it may be helpful to also query the parameter_refs and supports which will have a one-to-one correspondence with the output(s) of this function. These functions should all be called with the same keyword arguments for consistency.

source
JuMP.optimizer_indexMethod
JuMP.optimizer_index(ref::GeneralVariableRef; [kwargs...])

Extend JuMP.optimizer_index for refs in InfiniteModel. The exact format of output will depend on the transformation backend that is being used.

Thw keyword arguments kwargs depend on the transformation backend that is being used. The default backend TranscriptionOpt uses the keyword arguments:

  • label::Type{<:AbstractSupportLabel} = PublicLabel: the label of supports to be returned

By default only the values associated with public supports (i.e., PublicLabels) are returned, the full set can be accessed via label = All. Where possible, all the values of infinite objects are returned as an n-dimensional array where each dimension is determined by the each independent group of infinite parameters they depend on.

To provide context for the values, it may be helpful to also query the parameter_refs and supports which will have a one-to-one correspondence with the output(s) of this function. These functions should all be called with the same keyword arguments for consistency.

source

Constraints

JuMP.has_dualsMethod
JuMP.has_duals(model::InfiniteModel; result::Int = 1)

Extend JuMP.has_duals for InfiniteModels in accordance with that reported by its transformation backend. Errors if such a query is not supported or if the transformation backend hasn't be solved. Accepts keyword result to access the solution index of interest (if the solver/backend supports multiple solutions).

source
JuMP.valueMethod
JuMP.value(cref::InfOptConstraintRef; [kwargs...])

Extend JuMP.value to return the value(s) of cref in accordance with its reformulation constraint(s) stored in the transformation backend. Use JuMP.has_values to check whether a result exists before checking the values.

Thw keyword arguments kwargs depend on the transformation backend that is being used. The default backend TranscriptionOpt uses the keyword arguments:

  • result::Int = 1: indexes the solution result to be queried
  • label::Type{<:AbstractSupportLabel} = PublicLabel: the label of supports to be returned

By default only the values associated with public supports (i.e., PublicLabels) are returned, the full set can be accessed via label = All. Where possible, all the values of infinite constraints are returned as an n-dimensional array where each dimension is determined by the each independent group of infinite parameters they depend on.

To provide context for the values, it may be helpful to also query the constraint's parameter_refs and supports which will have a one-to-one correspondence with the value(s). It may also be helpful to query via transformation_constraint to retrieve the constraint(s) that these values are based on. These functions should all be called with the same keyword arguments for consistency.

For extensions, this only works if transformation_constraint has been extended correctly and/or map_value has been extended for constraints.

Example

julia> value(c1)
4-element Array{Float64,1}:
 -0.0
 20.9
 20.9
 20.9
source
JuMP.optimizer_indexMethod
JuMP.optimizer_index(ref::InfOptConstraintRef; [kwargs...])

Extend JuMP.optimizer_index for refs in InfiniteModel. The exact format of output will depend on the transformation backend that is being used.

Thw keyword arguments kwargs depend on the transformation backend that is being used. The default backend TranscriptionOpt uses the keyword arguments:

  • label::Type{<:AbstractSupportLabel} = PublicLabel: the label of supports to be returned

By default only the values associated with public supports (i.e., PublicLabels) are returned, the full set can be accessed via label = All. Where possible, all the values of infinite objects are returned as an n-dimensional array where each dimension is determined by the each independent group of infinite parameters they depend on.

To provide context for the values, it may be helpful to also query the parameter_refs and supports which will have a one-to-one correspondence with the output(s) of this function. These functions should all be called with the same keyword arguments for consistency.

source
JuMP.dualMethod
JuMP.dual(cref::InfOptConstraintRef; [kwargs...])

Extend JuMP.dual to return the dual(s) of cref in accordance with its reformulation constraint(s) stored in the transformation backend. Use JuMP.has_duals to check whether a result exists before checking the duals.

Thw keyword arguments kwargs depend on the transformation backend that is being used. The default backend TranscriptionOpt uses the keyword arguments:

  • result::Int = 1: indexes the solution result to be queried
  • label::Type{<:AbstractSupportLabel} = PublicLabel: the label of supports to be returned

By default only the values associated with public supports (i.e., PublicLabels) are returned, the full set can be accessed via label = All. Where possible, all the duals of infinite cosntraints are returned as an n-dimensional array where each dimension is determined by the each independent group of infinite parameters they depend on.

To provide context for the duals, it may be helpful to also query the constraint's parameter_refs and supports which will have a one-to-one correspondence with the value(s). It may also be helpful to query via transformation_constraint to retrieve the constraint(s) that these values are based on. These functions should all be called with the same keyword arguments for consistency.

For extensions, this only works if transformation_constraint has been extended correctly and/or map_dual has been extended for constraints.

Example

julia> dual(c1)
4-element Array{Float64,1}:
 -42.0
 -42.0
 32.3
 0.0
source
JuMP.shadow_priceMethod
JuMP.shadow_price(ref::InfOptConstraintRef; [kwargs...])

Extend JuMP.shadow_price for refs in InfiniteModel. The exact format of output will depend on the transformation backend that is being used.

Thw keyword arguments kwargs depend on the transformation backend that is being used. The default backend TranscriptionOpt uses the keyword arguments:

  • label::Type{<:AbstractSupportLabel} = PublicLabel: the label of supports to be returned

By default only the values associated with public supports (i.e., PublicLabels) are returned, the full set can be accessed via label = All. Where possible, all the values of infinite objects are returned as an n-dimensional array where each dimension is determined by the each independent group of infinite parameters they depend on.

To provide context for the values, it may be helpful to also query the parameter_refs and supports which will have a one-to-one correspondence with the output(s) of this function. These functions should all be called with the same keyword arguments for consistency.

source

Expressions

JuMP.valueMethod
JuMP.value(expr::JuMP.AbstractJuMPScalar; [kwargs...])

Extend JuMP.value to return the value(s) of vref in accordance with its reformulation expression(s) stored in the transformation backend. Use JuMP.has_values to check whether a result exists before checking the values.

Thw keyword arguments kwargs depend on the transformation backend that is being used. The default backend TranscriptionOpt uses the keyword arguments:

  • result::Int = 1: indexes the solution result to be queried
  • label::Type{<:AbstractSupportLabel} = PublicLabel: the label of supports to be returned

By default only the values associated with public supports (i.e., PublicLabels) are returned, the full set can be accessed via label = All. Where possible, all the values of infinite expressions are returned as an n-dimensional array where each dimension is determined by the each independent group of infinite parameters they depend on.

To provide context for the values, it may be helpful to also query the expression's parameter_refs and supports which will have a one-to-one correspondence with the value(s). It may also be helpful to query via transformation_expression to retrieve the expression(s) that these values are based on. These functions should all be called with the same keyword arguments for consistency.

For extensions, this only works if transformation_expression has been extended correctly and/or map_value has been extended for expressions.

Example

julia> value(my_finite_expr)
23.34

julia> value(my_infinite_expr)
4-element Array{Float64,1}:
 -0.0
 20.9
 20.9
 20.9
source

LP Sensitivity

JuMP.lp_sensitivity_reportMethod
JuMP.lp_sensitivity_report(
    model::InfiniteModel;
    [atol::Float64 = 1e-8]
    )::InfOptSensitivityReport

Extends JuMP.lp_sensitivity_report to generate and return an LP sensitivity report in accordance with the transformation backend. See InfOptSensitivityReport for syntax details on how to query it. atol denotes the optimality tolerance and should match that used by the solver to compute the basis. Please refer to JuMP's documentation for more technical information on interpretting the output of the report.

Example

julia> report = lp_sensitivity_report(model);

julia> report[x]
(0.0, 0.5)
source
InfiniteOpt.InfOptSensitivityReportType
InfOptSensitivityReport

A wrapper DataType for JuMP.SensitivityReports in InfiniteOpt. These are generated based on the transformation backend and should be made via the use of lp_sensitivity_report. Once made these can be indexed to get the sensitivies with respect to variables and/or constraints. The indexing syntax for these is:

report[ref::[GeneralVariableRef/InfOptConstraintRef]; 
       [label::Type{<:AbstractSupportLabel} = PublicLabel,
       kwargs...]]

This is enabled for new transformation backends by appropriately extending transformation_variable and transformation_constraint.

Fields

  • opt_report::JuMP.SensitivityReport: The LP sensitivity captured from the backend.
source

Transformation Backend Extension API

InfiniteOpt.map_valueMethod
map_value([ref/expr], backend::AbstractTransformationBackend; [kwargs...])

Map the value(s) of ref to its counterpart in the backend. Here ref need refer to methods for both variable references and constraint references. No extension is needed for JuMPBackends that support transformation_variable, transformation_expression, and transformation_constraint. In this case, transformation_variable, transformation_expression, and transformation_constraint are used to make these mappings by default where kwargs are passed on these functions. For mapping the values of infinite parameters, refer to map_infinite_parameter_value.

source
InfiniteOpt.map_infinite_parameter_valueFunction
map_infinite_parameter_value(
    pref::GeneralVariableRef, 
    backend::AbstractTransformationBackend;
    [kwargs...]
    )

Return the mapped value of the infinite parameter pref according to the backend. This serves as an optional extension point for new type of backends that do not rely on using supports. Otherwise, this defaults to:

map_infinite_parameter_value(pref; [label = PublicLabel]) = supports(pref, label = label)
source
InfiniteOpt.map_reduced_costMethod
map_reduced_cost(
    ref::GeneralVariableRef,
    backend::AbstractTransformationBackend;
    [kwargs...]
    )

Map JuMP.reduced_cost of ref to its counterpart in the backend. No extension is needed for JuMPBackends that support transformation_variable, in which case, transformation_variable is used to make these mappings using kwargs.

source
InfiniteOpt.map_optimizer_indexMethod
map_optimizer_index(
    ref::GeneralVariableRef,
    backend::AbstractTransformationBackend;
    [kwargs...]
    )

Map JuMP.optimizer_index of ref to its counterpart in the backend. No extension is needed for JuMPBackends that support transformation_variable, in which case, transformation_variable is used to make these mappings using kwargs.

source
InfiniteOpt.map_dualMethod
map_dual(
    cref::InfOptConstraintRef,
    backend::AbstractTransformationBackend;
    [kwargs...]
    )

Map the dual(s) of cref to its counterpart in the backend. No extension is needed for JuMPBackends that support transformation_constraint. In this case, transformation_constraint are used to make these mappings by default where kwargs are passed on these functions.

source
InfiniteOpt.map_shadow_priceMethod
map_shadow_price(
    ref::InfOptConstraintRef,
    backend::AbstractTransformationBackend;
    [kwargs...]
    )

Map JuMP.shadow_price of ref to its counterpart in the backend. No extension is needed for JuMPBackends that support transformation_constraint, in which case, transformation_constraint is used to make these mappings using kwargs.

source
InfiniteOpt.map_optimizer_indexMethod
map_optimizer_index(
    ref::InfOptConstraintRef,
    backend::AbstractTransformationBackend;
    [kwargs...]
    )

Map JuMP.optimizer_index of ref to its counterpart in the backend. No extension is needed for JuMPBackends that support transformation_constraint, in which case, transformation_constraint is used to make these mappings using kwargs.

source
JuMP.lp_sensitivity_reportMethod
JuMP.lp_sensitivity_report(
    backend::AbstractTransformationBackend;
    [atol::Float64 = 1e-8]
    )::InfOptSensitivityReport

Extend JuMP.lp_sensitivity_report as appropriate for backend. This is intended as an extension point. For JuMPBackends, this simply calls JuMP.lp_sensitivity_report on the underlying JuMP model.

source