API

An algebraic modeling language for Julia.

For more information, go to https://jump.dev.

An instance of the TerminationStatusCode enum.

ALMOST_DUAL_INFEASIBLE: The algorithm concluded that no dual bound exists for the problem within relaxed tolerances.

An instance of the TerminationStatusCode enum.

ALMOST_INFEASIBLE: The algorithm concluded that no feasible solution exists within relaxed tolerances.

An instance of the TerminationStatusCode enum.

ALMOST_LOCALLY_SOLVED: The algorithm converged to a stationary point, local optimal solution, or could not find directions for improvement within relaxed tolerances.

An instance of the TerminationStatusCode enum.

ALMOST_OPTIMAL: The algorithm found a globally optimal solution to relaxed tolerances.

moi_backend field holds a CachingOptimizer in AUTOMATIC mode.

moi_backend field holds an AbstractOptimizer. No extra copy of the model is stored. The moi_backend must support add_constraint etc.

An instance of the TerminationStatusCode enum.

DUAL_INFEASIBLE: The algorithm concluded that no dual bound exists for the problem. If, additionally, a feasible (primal) solution is known to exist, this status typically implies that the problem is unbounded, with some technical exceptions.

An instance of the OptimizationSense enum.

FEASIBILITY_SENSE: the model does not have an objective function

An instance of the ResultStatusCode enum.

FEASIBLE_POINT: the result vector is a feasible point.

An instance of the ResultStatusCode enum.

INFEASIBILITY_CERTIFICATE: the result vector is an infeasibility certificate. If the PrimalStatus is INFEASIBILITY_CERTIFICATE, then the primal result vector is a certificate of dual infeasibility. If the DualStatus is INFEASIBILITY_CERTIFICATE, then the dual result vector is a proof of primal infeasibility.

An instance of the TerminationStatusCode enum.

INFEASIBLE: The algorithm concluded that no feasible solution exists.

An instance of the TerminationStatusCode enum.

INFEASIBLE_OR_UNBOUNDED: The algorithm stopped because it decided that the problem is infeasible or unbounded; this occasionally happens during MIP presolve.

An instance of the ResultStatusCode enum.

INFEASIBLE_POINT: the result vector is an infeasible point.

An instance of the TerminationStatusCode enum.

INTERRUPTED: The algorithm stopped because of an interrupt signal.

An instance of the TerminationStatusCode enum.

INVALID_MODEL: The algorithm stopped because the model is invalid.

An instance of the TerminationStatusCode enum.

INVALID_OPTION: The algorithm stopped because it was provided an invalid option.

An instance of the TerminationStatusCode enum.

ITERATION_LIMIT: An iterative algorithm stopped after conducting the maximum number of iterations.

An instance of the TerminationStatusCode enum.

LOCALLY_INFEASIBLE: The algorithm converged to an infeasible point or otherwise completed its search without finding a feasible solution, without guarantees that no feasible solution exists.

An instance of the TerminationStatusCode enum.

LOCALLY_SOLVED: The algorithm converged to a stationary point, local optimal solution, could not find directions for improvement, or otherwise completed its search without global guarantees.

moi_backend field holds a CachingOptimizer in MANUAL mode.

An instance of the OptimizationSense enum.

MAX_SENSE: the goal is to maximize the objective function

An instance of the TerminationStatusCode enum.

MEMORY_LIMIT: The algorithm stopped because it ran out of memory.

An instance of the OptimizationSense enum.

MIN_SENSE: the goal is to minimize the objective function

An instance of the ResultStatusCode enum.

NEARLY_FEASIBLE_POINT: the result vector is feasible if some constraint tolerances are relaxed.

An instance of the ResultStatusCode enum.

NEARLY_INFEASIBILITY_CERTIFICATE: the result satisfies a relaxed criterion for a certificate of infeasibility.

An instance of the ResultStatusCode enum.

NEARLY_REDUCTION_CERTIFICATE: the result satisfies a relaxed criterion for an ill-posed certificate.

An instance of the TerminationStatusCode enum.

NODE_LIMIT: A branch-and-bound algorithm stopped because it explored a maximum number of nodes in the branch-and-bound tree.

An instance of the TerminationStatusCode enum.

NORM_LIMIT: The algorithm stopped because the norm of an iterate became too large.

An instance of the ResultStatusCode enum.

NO_SOLUTION: the result vector is empty.

An instance of the TerminationStatusCode enum.

NUMERICAL_ERROR: The algorithm stopped because it encountered unrecoverable numerical error.

An instance of the TerminationStatusCode enum.

OBJECTIVE_LIMIT: The algorithm stopped because it found a solution better than a minimum limit set by the user.

An instance of the TerminationStatusCode enum.

OPTIMAL: The algorithm found a globally optimal solution.

An instance of the TerminationStatusCode enum.

OPTIMIZE_NOT_CALLED: The algorithm has not started.

An instance of the TerminationStatusCode enum.

OTHER_ERROR: The algorithm stopped because of an error not covered by one of the statuses defined above.

An instance of the TerminationStatusCode enum.

OTHER_LIMIT: The algorithm stopped due to a limit not covered by one of the LIMIT statuses above.

An instance of the ResultStatusCode enum.

OTHER_RESULT_STATUS: the result vector contains a solution with an interpretation not covered by one of the statuses defined above

An instance of the ResultStatusCode enum.

REDUCTION_CERTIFICATE: the result vector is an ill-posed certificate; see this article for details. If the PrimalStatus is REDUCTION_CERTIFICATE, then the primal result vector is a proof that the dual problem is ill-posed. If the DualStatus is REDUCTION_CERTIFICATE, then the dual result vector is a proof that the primal is ill-posed.

An instance of the TerminationStatusCode enum.

SLOW_PROGRESS: The algorithm stopped because it was unable to continue making progress towards the solution.

An instance of the TerminationStatusCode enum.

SOLUTION_LIMIT: The algorithm stopped because it found the required number of solutions. This is often used in MIPs to get the solver to return the first feasible solution it encounters.

An instance of the TerminationStatusCode enum.

TIME_LIMIT: The algorithm stopped after a user-specified computation time.

An instance of the ResultStatusCode enum.

UNKNOWN_RESULT_STATUS: the result vector contains a solution with an unknown interpretation.

A global constant used to control when constraints are omitted when printing the model.

Get and set this value using _CONSTRAINT_LIMIT_FOR_PRINTING[].

A global constant used to control when terms are omitted when printing expressions.

Get and set this value using _TERM_LIMIT_FOR_PRINTING[].

A function that falls back to x & y, but when called with JuMP variables or expressions, returns a GenericNonlinearExpr.

Example

A function that falls back to x == y, but when called with JuMP variables or expressions, returns a GenericNonlinearExpr.

Example

A function that falls back to x >= y, but when called with JuMP variables or expressions, returns a GenericNonlinearExpr.

Example

A function that falls back to x <= y, but when called with JuMP variables or expressions, returns a GenericNonlinearExpr.

Example

A function that falls back to x | y, but when called with JuMP variables or expressions, returns a GenericNonlinearExpr.

Example

A function that falls back to x > y, but when called with JuMP variables or expressions, returns a GenericNonlinearExpr.

Example

A function that falls back to x < y, but when called with JuMP variables or expressions, returns a GenericNonlinearExpr.

Example

An abstract base type for all constraint types. AbstractConstraints store the function and set directly, unlike ConstraintRefs that are merely references to constraints stored in a model. AbstractConstraints do not need to be attached to a model.

Abstract base type for all scalar types

The subtyping of AbstractMutable will allow calls of some Base functions to be redirected to a method in MA that handles type promotion more carefully (for example the promotion in sparse matrix products in SparseArrays usually does not work for JuMP types) and exploits the mutability of AffExpr and QuadExpr.

An abstract type that should be subtyped for users creating JuMP extensions.

An abstract type for defining new scalar sets in JuMP.

Implement moi_set(::AbstractScalarSet) to convert the type into an MOI set.

See also: moi_set.

Abstract vectorizable shape. Given a flat vector form of an object of shape shape, the original object can be obtained by reshape_vector.

Variable returned by build_variable. It represents a variable that has not been added yet to any model. It can be added to a given model with add_variable.

Variable returned by add_variable. Affine (resp. quadratic) operations with variables of type V<:AbstractVariableRef and coefficients of type T create a GenericAffExpr{T,V} (resp. GenericQuadExpr{T,V}).

An abstract type for defining new sets in JuMP.

Implement moi_set(::AbstractVectorSet, dim::Int) to convert the type into an MOI set.

See also: moi_set.

Alias for GenericAffExpr{Float64,VariableRef}, the specific GenericAffExpr used by JuMP.

An AbstractShape that represents array-valued constraints.

Example

An AbstractConstraint representinng that constraint that can be bridged by the bridge of type bridge_type{coefficient_type}.

Adding a BridgeableConstraint to a model is equivalent to:

Example

Given a new scalar set type CustomSet with a bridge CustomBridge that can bridge F-in-CustomSet constraints, when the user does:

with an optimizer that does not support F-in-CustomSet constraints, the constraint will not be bridged unless they first call add_bridge(model, CustomBridge).

In order to automatically add the CustomBridge to any model to which an F-in-CustomSet is added, add the following method:

Note

JuMP extensions should extend JuMP.build_constraint only if they also defined CustomSet, for three reasons:

Complex plane object that can be used to create a complex variable in the @variable macro.

Example

Consider the following example:

We see in the output of the last command that two real variables were created. The Julia variable x binds to an affine expression in terms of these two variables that parametrize the complex plane.

A struct used when adding complex variables.

See also: ComplexPlane.

An error thrown when the constraint constraint_ref was used in a model different to owner_model(constraint_ref).

Example

Holds a reference to the model and the corresponding MOI.ConstraintIndex.

An expression type representing an affine expression of the form: .

Fields

Example

Create a GenericAffExpr by passing a constant and pairs of additional arguments.

Example

Create a GenericAffExpr by passing a constant and a vector of pairs.

Example

Create a new instance of a JuMP model.

If optimizer_factory is provided, the model is initialized with the optimizer returned by MOI.instantiate(optimizer_factory).

If optimizer_factory is not provided, use set_optimizer to set the optimizer before calling optimize!.

If add_bridges, JuMP adds a MOI.Bridges.LazyBridgeOptimizer to automatically reformulate the problem into a form supported by the optimizer.

Value type T

Passing a type other than Float64 as the value type T is an advanced operation. The value type must match that expected by the chosen optimizer. Consult the optimizers documentation for details.

If not documented, assume that the optimizer supports only Float64.

Choosing an unsupported value type will throw an MOI.UnsupportedConstraint or an MOI.UnsupportedAttribute error, the timing of which (during the model construction or during a call to optimize!) depends on how the solver is interfaced to JuMP.

Example

The scalar-valued nonlinear function head(args...), represented as a symbolic expression tree, with the call operator head and ordered arguments in args.

V is the type of AbstractVariableRef present in the expression, and is used to help dispatch JuMP extensions.

head

The head::Symbol must be an operator supported by the model.

The default list of supported univariate operators is given by:

and the default list of supported multivariate operators is given by:

Additional operators can be add using @operator.

See the full list of operators supported by a MOI.ModelLike by querying the MOI.ListOfSupportedNonlinearOperators attribute.

args

The vector args contains the arguments to the nonlinear function. If the operator is univariate, it must contain one element. Otherwise, it may contain multiple elements.

Given a subtype of AbstractVariableRef, V, for GenericNonlinearExpr{V}, each element must be one of the following:

where T<:Real and T == value_type(V).

Unsupported operators

If the optimizer does not support head, an MOI.UnsupportedNonlinearOperator error will be thrown.

There is no guarantee about when this error will be thrown; it may be thrown when the function is first added to the model, or it may be thrown when optimize! is called.

Example

To represent the function , do:

An expression type representing an quadratic expression of the form: .

Fields

Example

Create a GenericQuadExpr by passing a GenericAffExpr and a vector of (UnorderedPair, coefficient) pairs.

Example

Mapping between variable and constraint reference of a model and its copy. The reference of the copied model can be obtained by indexing the map with the reference of the corresponding reference of the original model.

Holds a reference to the model and the corresponding MOI.VariableIndex.

Get the variable associated with a ConstraintRef, if c is a constraint on a single variable.

Example

A struct used to intercept when >= or ≥ is used in a macro via operator_to_set.

This struct is not the same as Nonnegatives so that we can disambiguate x >= y and x - y in Nonnegatives().

This struct is not intended for general usage, but it may be useful to some JuMP extensions.

Example

The dual_shape of HermitianMatrixShape.

This shape is not intended for regular use.

The shape object for a Hermitian square matrix of side_dimension rows and columns.

The vectorized form corresponds to MOI.HermitianPositiveSemidefiniteConeTriangle.

needs_adjoint_dual

By default, the dual_shape of HermitianMatrixShape is also HermitianMatrixShape. This is true for cases such as a LinearAlgebra.Hermitian matrix in HermitianPSDCone.

However, JuMP also supports LinearAlgebra.Hermitian matrix in Zeros, which is interpreted as an element-wise equality constraint. By exploiting symmetry, we pass only the upper triangle of the equality constraints. This works for the primal, but it leads to a factor of 2 difference in the off-diagonal dual elements. (The dual value of the (i, j) element in the triangle formulation should be divided by 2 when spread across the (i, j) and (j, i) elements in the square matrix formulation.) If the constraint has this dual inconsistency, set needs_adjoint_dual = true.

Use in the @variable macro to constrain a matrix of variables to be hermitian.

Example

Hermitian positive semidefinite cone object that can be used to create a Hermitian positive semidefinite square matrix in the @variable and @constraint macros.

Example

Consider the following example:

We see in the output of the last commands that 9 real variables were created. The matrix H constrains affine expressions in terms of these 9 variables that parametrize a Hermitian matrix.

The struct returned by lp_matrix_data. See lp_matrix_data for a description of the public fields.

A struct used to intercept when <= or ≤ is used in a macro via operator_to_set.

This struct is not the same as Nonpositives so that we can disambiguate x <= y and x - y in Nonpositives().

This struct is not intended for general usage, but it may be useful to some JuMP extensions.

Example

A struct that implements the iterate protocol in order to iterate over tuples of (coefficient, variable) in the GenericAffExpr.

Create a new instance of a JuMP model.

If optimizer_factory is provided, the model is initialized with thhe optimizer returned by MOI.instantiate(optimizer_factory).

If optimizer_factory is not provided, use set_optimizer to set the optimizer before calling optimize!.

If add_bridges, JuMP adds a MOI.Bridges.LazyBridgeOptimizer to automatically reformulate the problem into a form supported by the optimizer.

Example

An enum to describe the state of the CachingOptimizer inside a JuMP model.

See also: mode.

Values

Possible values are:

An error thrown when no optimizer is set and one is required.

The optimizer can be provided to the Model constructor or by calling set_optimizer.

Example

Alias for GenericNonlinearExpr{VariableRef}, the specific GenericNonlinearExpr used by JuMP.

A struct to represent a nonlinear expression.

Create an expression using @NLexpression.

A callable struct (functor) representing a function named head.

When called with AbstractJuMPScalars, the struct returns a GenericNonlinearExpr.

When called with non-JuMP types, the struct returns the evaluation of func(args...).

Unless head is special-cased by the optimizer, the operator must have already been added to the model using add_nonlinear_operator or @operator.

Example

A struct to represent a nonlinear parameter.

Create a parameter using @NLparameter.

The JuMP equivalent of the MOI.Nonnegatives set, in which the dimension is inferred from the corresponding function.

Example

The JuMP equivalent of the MOI.Nonpositives set, in which the dimension is inferred from the corresponding function.

Example

An error thrown when a result attribute cannot be queried before optimize! is called.

Example

Positive semidefinite cone object that can be used to constrain a square matrix to be positive semidefinite in the @constraint macro.

If the matrix has type Symmetric then the columns vectorization (the vector obtained by concatenating the columns) of its upper triangular part is constrained to belong to the MOI.PositiveSemidefiniteConeTriangle set, otherwise its column vectorization is constrained to belong to the MOI.PositiveSemidefiniteConeSquare set.

Example

Non-symmetric case:

Symmetric case:

A short-cut for the MOI.Parameter set.

Example

An alias for GenericQuadExpr{Float64,VariableRef}, the specific GenericQuadExpr used by JuMP.

A struct that implements the iterate protocol in order to iterate over tuples of (coefficient, variable, variable) in the GenericQuadExpr.

Rotated second order cone object that can be used to constrain the square of the euclidean norm of a vector x to be less than or equal to where t and u are nonnegative scalars. This is a shortcut for the MOI.RotatedSecondOrderCone.

Example

The following constrains and :

The SOS1 (Special Ordered Set of Type 1) set constrains a vector x to the set where at most one variable can take a non-zero value, and all other elements are zero.

The weights vector, if specified, induces an ordering of the variables; as such, it should contain unique values. The weights vector must have the same number of elements as the vector x, and the element weights[i] corresponds to element x[i]. If not provided, the weights vector defaults to weights[i] = i.

This is a shortcut for the MOI.SOS1 set.

Example

The SOS2 (Special Ordered Set of Type 2) set constrains a vector x to the set where at most two variables can take a non-zero value, and all other elements are zero. In addition, the two non-zero values must be consecutive given the ordering of the x vector induced by weights.

The weights vector, if specified, induces an ordering of the variables; as such, it must contain unique values. The weights vector must have the same number of elements as the vector x, and the element weights[i] corresponds to element x[i]. If not provided, the weights vector defaults to weights[i] = i.

This is a shortcut for the MOI.SOS2 set.

Example

The data for a scalar constraint.

See also the documentation on JuMP’s representation of constraints for more background.

Fields

Example

A scalar constraint:

An AbstractShape that represents scalar constraints.

Example

A struct used when adding variables.

See also: add_variable.

Second order cone object that can be used to constrain the euclidean norm of a vector x to be less than or equal to a nonnegative scalar t. This is a shortcut for the MOI.SecondOrderCone.

Example

The following constrains and :

A short-cut for the MOI.Semicontinuous set.

This short-cut is useful because it automatically promotes lower and upper to the same type, and converts them into the element type supported by the JuMP model.

Example

A short-cut for the MOI.Semiinteger set.

This short-cut is useful because it automatically promotes lower and upper to the same type, and converts them into the element type supported by the JuMP model.

Example

See lp_sensitivity_report.

Shape object for a skew symmetric square matrix of side_dimension rows and columns. The vectorized form contains the entries of the upper-right triangular part of the matrix (without the diagonal) given column by column (or equivalently, the entries of the lower-left triangular part given row by row). The diagonal is zero.

Use in the @variable macro to constrain a matrix of variables to be skew-symmetric.

Example

JuMP uses model_convert](api.md#JuMP.model_convert-Tuple{AbstractModel, Any}) to automatically promote [MOI.AbstractScalarSet sets to the same value_type as the model.

In cases there this is undesirable, wrap the set in SkipModelConvertScalarSetWrapper to pass the set un-changed to the solver.

Example

Shape object for a square matrix of side_dimension rows and columns. The vectorized form contains the entries of the matrix given column by column (or equivalently, the entries of the lower-left triangular part given row by row).

The dual_shape of SymmetricMatrixShape.

This shape is not intended for regular use.

The shape object for a symmetric square matrix of side_dimension rows and columns.

The vectorized form contains the entries of the upper-right triangular part of the matrix given column by column (or equivalently, the entries of the lower-left triangular part given row by row).

needs_adjoint_dual

By default, the dual_shape of SymmetricMatrixShape is also SymmetricMatrixShape. This is true for cases such as a LinearAlgebra.Symmetric matrix in PSDCone.

However, JuMP also supports LinearAlgebra.Symmetric matrix in Zeros, which is interpreted as an element-wise equality constraint. By exploiting symmetry, we pass only the upper triangle of the equality constraints. This works for the primal, but it leads to a factor of 2 difference in the off-diagonal dual elements. (The dual value of the (i, j) element in the triangle formulation should be divided by 2 when spread across the (i, j) and (j, i) elements in the square matrix formulation.) If the constraint has this dual inconsistency, set needs_adjoint_dual = true.

Use in the @variable macro to constrain a matrix of variables to be symmetric.

Example

A wrapper type used by GenericQuadExpr with fields .a and .b.

Example

Variable scalar_variables constrained to belong to set.

Adding this variable can be understood as doing:

but adds the variables with MOI.add_constrained_variable(model, variable.set) instead.

A struct by JuMP internally when creating variables. This may also be used by JuMP extensions to create new types of variables.

See also: ScalarVariable.

The variable variable was used in a model different to owner_model(variable).

Vector of variables scalar_variables constrained to belong to set. Adding this variable can be thought as doing:

but adds the variables with MOI.add_constrained_variables(model, variable.set) instead. See the MOI documentation for the difference between adding the variables with MOI.add_constrained_variables and adding them with MOI.add_variables and adding the constraint separately.

The data for a vector constraint.

See also the documentation on JuMP’s representation of constraints.

Fields

Example

An AbstractShape that represents vector-valued constraints.

Example

The JuMP equivalent of the MOI.Zeros set, in which the dimension is inferred from the corresponding function.

Example

A lazy cache used for computing the primal variable solution in value.

This avoids the need to rewrite the nonlinear expressions from MOI*VARIABLE to VARIABLE, as well as eagerly computing the var*valuefor every variable. We use acache so we don’t have to recompute variables we have already seen.

Return a copy of the model model. It is similar to copy_model except that it does not return the mapping between the references of model and its copy.

Note

Model copy is not supported in DIRECT mode, that is, when a model is constructed using the direct_model constructor instead of the Model constructor. Moreover, independently on whether an optimizer was provided at model construction, the new model will have no optimizer, that is, an optimizer will have to be provided to the new model in the optimize! call.

Example

In the following example, a model model is constructed with a variable x and a constraint cref. It is then copied into a model new_model with the new references assigned to x_new and cref_new.

Empty the model, that is, remove all variables, constraints and model attributes but not optimizer attributes. Always return the argument.

Example

To allow easy accessing of JuMP Variables and Constraints via [] syntax.

Returns the variable, or group of variables, or constraint, or group of constraints, of the given name which were added to the model. This errors if multiple variables or constraints share the same name.

Determine whether the model has a mapping for a given name.

Verifies whether the model is empty, that is, whether the MOI backend is empty and whether the model is in the same state as at its creation, apart from optimizer attributes.

Example

Return a JuMP model read from io in the format format.

Other kwargs are passed to the Model constructor of the chosen format.

Stores the object value in the model m using so that it can be accessed via getindex. Can be called with [] syntax.

Write a summary of the solution results to io (or to stdout if io is not given).

Write the JuMP model model to io in the format format.

Other kwargs are passed to the Model constructor of the chosen format.

Return a constraint reference to the constraint constraining v to be binary. Errors if one does not exist.

See also is_binary, set_binary, unset_binary.

Example

Return a constraint reference to the constraint fixing the value of v.

Errors if one does not exist.

See also is_fixed, fix_value, fix, unfix.

Example

Return a constraint reference to the constraint constraining v to be integer.

Errors if one does not exist.

See also is_integer, set_integer, unset_integer.

Example

Return a constraint reference to the lower bound constraint of v.

Errors if one does not exist.

See also has_lower_bound, lower_bound, set_lower_bound, delete_lower_bound.

Example

Return an MOI.AbstractNLPEvaluator constructed from model

Experimental

These features may change or be removed in any future version of JuMP.

Pass _differentiation_backend to specify the differentiation backend used to compute derivatives.

Return a constraint reference to the constraint constraining x to be a parameter.

Errors if one does not exist.

See also is_parameter, set_parameter_value, parameter_value.

Example

Return a constraint reference to the upper bound constraint of v.

Errors if one does not exist.

See also has_upper_bound, upper_bound, set_upper_bound, delete_upper_bound.

Example

Assume we start with the optimal solution x_old, we want to compute a step size t in a direction d such that x_new = x_old + t * d is still represented by the same optimal basis. This can be computed a la primal simplex where we use an artificial entering variable.

Note we only have to compute the basic component of the direction vector, because d_N is just zeros with a 1 in the component associated with the artificial entering variable. Therefore, all that remains is to compute the associated column of N.

If we are increasing the bounds associated with the ith decision variable, then our artificial entering variable is a duplicate of the ith variable, and N * d_N = A[:, i].

If we are increasing the bounds associated with the ith affine constraint, then our artificial entering variable is a duplicate of the slack variable associated with the ith constraint, that is, a -1 in the ith row and zeros everywhere else.

In either case:

Now, having computed a direction such that x_new = x_old + t * d. By ensuring that A * d = 0, we maintained structural feasibility. Now we need to compute bounds on t such that x_new maintains bound feasibility. That is, compute bounds on t such that:

If x is an AbstractSparseArray, return the dense equivalent, otherwise just return x.

This function is used in _build_constraint.

Why is this needed?

When broadcasting f.(x) over an AbstractSparseArray x, Julia first calls the equivalent of f(zero(eltype(x)). Here’s an example:

However, if f is mutating, this can have serious consequences! In our case, broadcasting build_constraint will add a new 0 = 0 constraint.

Sparse arrays most-often arise when some input data to the constraint is sparse (for example, a constant vector or matrix). Due to promotion and arithmetic, this results in a constraint function that is represented by an AbstractSparseArray, but is actually dense. Thus, we can safely collect the matrix into a dense array.

If the function is sparse, it’s not obvious what to do. What is the "zero" element of the result? What does it mean to broadcast build_constraint over a sparse array adding scalar constraints? This likely means that the user is using the wrong data structure. For simplicity, let’s also call collect into a dense array, and wait for complaints.

In many cases, @variable can return a GenericAffExpr instead of a GenericVariableRef. This is particularly the case for complex-valued expressions. To make common operations like lower_bound(x) work, we should forward the method if and only if x is convertable to a GenericVariableRef.

Fills the vectors terms at indices starting at offset+1 with the affine terms of aff. The output index for all terms is oi. Return the index of the last term added.

Fills the vectors terms at indices starting at offset+1 with the quadratic terms of quad. The output index for all terms is oi. Return the index of the last term added.

Wraps the code generated by a macro in a code block with the first argument as source, the LineNumberNode of where the macro was called from in the user’s code. This results in better stacktraces in error messages.

In addition, this function adds a check that model is a valid AbstractModel.

If register_name is a Symbol, register the result of code in model under the name register_name.

If wrap_let, wraps code in a let model = model block to enforce the model as a local variable.

Return true if model is a linear program.

Return the MOI.ScalarQuadraticTerm for the quadratic term t, element of the quad_terms iterator. Note that the VariableRefs are transformed into MOI.VariableIndexs hence the owner model information is lost.

Returns the nonlinear objective function or nothing if no nonlinear objective function is set.

JuMP needs to build Nonlinear expression objects in macro scope. This has two main challenges:

Print a LaTeX formulation of model to io.

For this method to work, an AbstractModel subtype must implement:

Print a plain-text formulation of model to io.

For this method to work, an AbstractModel subtype must implement:

Print a plain-text summary of model to io.

For this method to work, an AbstractModel subtype should implement:

Replaces _MA.Zero with a floating point zero(value_type(M)).

If expr is not an Expr, then rewriting it won’t do anything. We just need to copy if it is mutable so that future operations do not modify the user’s data.

A helper function so that we can change how we rewrite expressions in a single place and have it cascade to all locations in the JuMP macros that rewrite expressions.

See lp_matrix_data instead.

Add BT{T} to the list of bridges that can be used to transform unsupported constraints into an equivalent formulation using only constraints supported by the optimizer.

See also: remove_bridge.

Example

This method should only be implemented by developers creating JuMP extensions. It should never be called by users of JuMP.

Add a nonlinear constraint described by the Julia expression ex to model.

This function is most useful if the expression ex is generated programmatically, and you cannot use @NLconstraint.

Notes

Example

Add a nonlinear expression expr to model.

This function is most useful if the expression expr is generated programmatically, and you cannot use @NLexpression.

Notes

Example

Add a new nonlinear operator with dim input arguments to model and associate it with the name name.

The function f evaluates the operator and must return a scalar.

The optional function ∇f evaluates the first derivative, and the optional function ∇²f evaluates the second derivative.

∇²f may be provided only if ∇f is also provided.

Univariate syntax

If dim == 1, then the method signatures of each function must be:

Multivariate syntax

If dim > 1, then the method signatures of each function must be:

Where the gradient vector g and Hessian matrix H are filled in-place. For the Hessian, you must fill in the non-zero lower-triangular entries only. Setting an off-diagonal upper-triangular element may error.

Example

Add an anonymous parameter to the model.

Updates expression in-place to expression + (*)(terms...).

This is typically much more efficient than expression += (*)(terms...) because it avoids the temorary allocation of the right-hand side term.

For example, add_to_expression!(expression, a, b) produces the same result as expression += a*b, and add_to_expression!(expression, a) produces the same result as expression += a.

When to implement

Only a few methods are defined, mostly for internal use, and only for the cases when:

Example

Add value to the function constant term of constraint.

Note that for scalar constraints, JuMP will aggregate all constant terms onto the right-hand side of the constraint so instead of modifying the function, the set will be translated by -value. For example, given a constraint 2x <= 3, add_to_function_constant(c, 4) will modify it to 2x <= -1.

Example

For scalar constraints, the set is translated by -value:

For vector constraints, the constant is added to the function:

This method should only be implemented by developers creating JuMP extensions. It should never be called by users of JuMP.

Return a list of all constraints currently in the model where the function has type function_type and the set has type set_type. The constraints are ordered by creation time.

See also list_of_constraint_types and num_constraints.

Example

Return a list of all constraints in model.

If include_variable_in_set_constraints == true, then VariableRef constraints such as VariableRef-in-Integer are included. To return only the structural constraints (for example, the rows in the constraint matrix of a linear program), pass include_variable_in_set_constraints = false.

Example

Performance considerations

Note that this function is type-unstable because it returns an abstractly typed vector. If performance is a problem, consider using list_of_constraint_types and a function barrier. See the Performance tips for extensions section of the documentation for more details.

Return a vector of all nonlinear constraint references in the model in the order they were added to the model.

This function returns only the constraints added with @NLconstraint and add_nonlinear_constraint. It does not return GenericNonlinearExpr constraints.

Returns a list of all variables currently in the model. The variables are ordered by creation time.

Example

The name to use for an anonymous variable x when printing.

Example

Return the lower-level MathOptInterface model that sits underneath JuMP. This model depends on which operating mode JuMP is in (see mode).

Use index to get the index of a variable or constraint in the backend model.

Notes

If JuMP is not in DIRECT mode, the type returned by backend may change between any JuMP releases. Therefore, only use the public API exposed by MathOptInterface, and do not access internal fields. If you require access to the innermost optimizer, see unsafe_backend. Alternatively, use direct_model to create a JuMP model in DIRECT mode.

See also: unsafe_backend.

Example

If available, returns the cumulative number of barrier iterations during the most-recent optimization (the MOI.BarrierIterations attribute).

Throws a MOI.GetAttributeNotAllowed error if the attribute is not implemented by the solver.

Example

When in direct mode, return false.

When in manual or automatic mode, return a Bool indicating whether the optimizer is set and unsupported constraints are automatically bridged to equivalent supported constraints when an appropriate transformation is available.

Example

This method should only be implemented by developers creating JuMP extensions. It should never be called by users of JuMP.

Return a new AbstractVariable object.

This method should only be implemented by developers creating JuMP extensions. It should never be called by users of JuMP.

Arguments

See also: @variable

Example

will call

Passing special-case positional arguments such as Bin, Int, and PSD is okay, along with keyword arguments:

will call

and info.integer will be true.

Note that the order of the positional arguments does not matter.

Return an MOI.CallbackNodeStatusCode enum, indicating if the current primal solution available from callback_value is integer feasible.

Example

Return the primal solution of x inside a callback.

cb_data is the argument to the callback function, and the type is dependent on the solver.

Use callback_node_status to check whether a solution is available.

Example

Throw VariableNotOwned if the owner_model of x is not model.

Example

Throw ConstraintNotOwned if owner_model(con_ref) is not model.

Return one(T) if v1 == v2 and zero(T) otherwise.

This is a fallback for other coefficient methods to simplify code in which the expression may be a single variable.

Example

Return the coefficient associated with variable v in the affine expression a.

Example

Return the coefficient associated with the term v1 * v2 in the quadratic expression a.

Note that coefficient(a, v1, v2) is the same as coefficient(a, v2, v1).

Example

Return the coefficient associated with variable v in the affine component of a.

Example

Compute a conflict if the model is infeasible.

The conflict is also called the Irreducible Infeasible Subsystem (IIS).

If an optimizer has not been set yet (see set_optimizer), a NoOptimizer error is thrown.

The status of the conflict can be checked with the MOI.ConflictStatus model attribute. Then, the status for each constraint can be queried with the MOI.ConstraintConflictStatus attribute.

See also: copy_conflict

Example

Return the constant of the affine expression.

Example

Return the constant of the quadratic expression.

Example

Return the reference of the constraint with name attribute name or Nothing if no constraint has this name attribute.

Throws an error if several constraints have name as their name attribute.

If F and S are provided, this method addititionally throws an error if the constraint is not an F-in-S contraint where F is either the JuMP or MOI type of the function and S is the MOI type of the set.

Providing F and S is recommended if you know the type of the function and set since its returned type can be inferred while for the method above (that is, without F and S), the exact return type of the constraint index cannot be inferred.

Example

Return the underlying constraint data for the constraint referenced by con_ref.

Example

A scalar constraint:

A vector constraint:

Return a ConstraintRef of model corresponding to index.

This function is a helper function used internally by JuMP and some JuMP extensions. It should not need to be called in user-code.

Return a string representation of the constraint ref, given the mode.

Example

Return a list of Strings describing each constraint of the model.

Example

Return a copy of the current conflict for the model model and a GenericReferenceMap that can be used to obtain the variable and constraint reference of the new model corresponding to a given model's reference.

This is a convenience function that provides a filtering function for copy_model.

Note

Model copy is not supported in DIRECT mode, that is, when a model is constructed using the direct_model constructor instead of the Model constructor. Moreover, independently on whether an optimizer was provided at model construction, the new model will have no optimizer, that is, an optimizer will have to be provided to the new model in the optimize! call.

Example

In the following example, a model model is constructed with a variable x and two constraints c1 and c2. This model has no solution, as the two constraints are mutually exclusive. The solver is asked to compute a conflict with compute_conflict!. The parts of model participating in the conflict are then copied into a model iis_model.

Return a copy of the extension data data of the model model to the extension data of the new model new_model.

A method should be added for any JuMP extension storing data in the ext field.

This method should only be implemented by developers creating JuMP extensions. It should never be called by users of JuMP.

Return a copy of the model model and a GenericReferenceMap that can be used to obtain the variable and constraint reference of the new model corresponding to a given model's reference. A Base.copy(::AbstractModel) method has also been implemented, it is similar to copy_model but does not return the reference map.

If the filter_constraints argument is given, only the constraints for which this function returns true will be copied. This function is given a constraint reference as argument.

Note

Model copy is not supported in DIRECT mode, that is, when a model is constructed using the direct_model constructor instead of the Model constructor. Moreover, independently on whether an optimizer was provided at model construction, the new model will have no optimizer, that is, an optimizer will have to be provided to the new model in the optimize! call.

Example

In the following example, a model model is constructed with a variable x and a constraint cref. It is then copied into a model new_model with the new references assigned to x_new and cref_new.

Delete the constraint associated with constraint_ref from the model model.

Note that delete does not unregister the name from the model, so adding a new constraint of the same name will throw an error. Use unregister to unregister the name after deletion.

Example

Delete the variable associated with variable_ref from the model model.

Note that delete does not unregister the name from the model, so adding a new variable of the same name will throw an error. Use unregister to unregister the name after deletion.

Example

Delete the constraints associated with con_refs from the model model.

Solvers may implement specialized methods for deleting multiple constraints of the same concrete type. These methods may be more efficient than repeatedly calling the single constraint delete method.

See also: unregister

Example

Delete the variables associated with variable_refs from the model model. Solvers may implement methods for deleting multiple variables that are more efficient than repeatedly calling the single variable delete method.

See also: unregister

Example

Delete the lower bound constraint of a variable.

See also LowerBoundRef, has_lower_bound, lower_bound, set_lower_bound.

Example

Delete the upper bound constraint of a variable.

Errors if one does not exist.

See also UpperBoundRef, has_upper_bound, upper_bound, set_upper_bound.

Example

Return a new JuMP model using backend to store the model and solve it.

As opposed to the Model constructor, no cache of the model is stored outside of backend and no bridges are automatically applied to backend.

Notes

The absence of a cache reduces the memory footprint but, it is important to bear in mind the following implications of creating models using this direct mode:

Create a direct_generic_model using factory, a MOI.OptimizerWithAttributes object created by optimizer_with_attributes.

Example

is equivalent to:

Return a new JuMP model using backend to store the model and solve it.

As opposed to the Model constructor, no cache of the model is stored outside of backend and no bridges are automatically applied to backend.

Notes

The absence of a cache reduces the memory footprint but, it is important to bear in mind the following implications of creating models using this direct mode:

Create a direct_model using factory, a MOI.OptimizerWithAttributes object created by optimizer_with_attributes.

Example

is equivalent to:

Remove terms in the affine expression with 0 coefficients.

Example

Remove terms in the quadratic expression with 0 coefficients.

Example

Return the dual value of constraint con_ref associated with result index result of the most-recent solution returned by the solver.

Use has_duals to check if a result exists before asking for values.

See also: result_count, shadow_price.

Example

Return the value of the objective of the dual problem associated with result index result of the most-recent solution returned by the solver.

Throws MOI.UnsupportedAttribute{MOI.DualObjectiveValue} if the solver does not support this attribute.

This function is equivalent to querying the MOI.DualObjectiveValue attribute.

See also: result_count.

Example

Returns the shape of the dual space of the space of objects of shape shape. By default, the dual_shape of a shape is itself. See the examples section below for an example for which this is not the case.

Example

Consider polynomial constraints for which the dual is moment constraints and moment constraints for which the dual is polynomial constraints. Shapes for polynomials can be defined as follows:

and a shape for moments can be defined as follows:

Then dual_shape allows the definition of the shape of the dual of polynomial and moment constraints:

Return the dual start value (MOI attribute ConstraintDualStart) of the constraint con_ref.

If no dual start value has been set, dual_start_value will return nothing.

See also set_dual_start_value.

Example

Return a MOI.ResultStatusCode describing the status of the most recent dual solution of the solver (that is, the MOI.DualStatus attribute) associated with the result index result.

See also: result_count.

Example

Errors if model is in direct mode during a call from the function named func.

Used internally within JuMP, or by JuMP extensions who do not want to support models in direct mode.

Example

Fix a variable to a value. Update the fixing constraint if one exists, otherwise create a new one.

If the variable already has variable bounds and force=false, calling fix will throw an error. If force=true, existing variable bounds will be deleted, and the fixing constraint will be added. Note a variable will have no bounds after a call to unfix.

See also FixRef, is_fixed, fix_value, unfix.

Example

Modifies model to convert all binary and integer variables to continuous variables with fixed bounds of var_value(x).

Return

Returns a function that can be called without any arguments to restore the original model. The behavior of this function is undefined if additional changes are made to the affected variables in the meantime.

Notes

Example

Return the value to which a variable is fixed.

Error if one does not exist.

See also FixRef, is_fixed, fix, unfix.

Example

Flatten a nonlinear expression in-place by lifting nested + and * nodes into a single n-ary operation.

Motivation

Nonlinear expressions created using operator overloading can be deeply nested and unbalanced. For example, prod(x for i in 1:4) creates (x, *(x, *(x, x))) instead of the more preferable (x, x, x, x).

Example

Return a String representing the function func using print mode mode.

Example

Get the value of a solver-specifc attribute attr.

This is equivalent to calling MOI.get](api.md#MathOptInterface.get-Tuple{GenericModel, MathOptInterface.AbstractModelAttribute}) with the associated MOI model and, for variables and constraints, with the associated [MOI.VariableIndex or MOI.ConstraintIndex.

Example

Get the value of a solver-specifc attribute attr.

This is equivalent to calling MOI.get with the associated MOI model.

If attr is an AbstractString, it is converted to MOI.RawOptimizerAttribute.

Example

Return the value associated with the solver-specific attribute attr.

If attr is an AbstractString, this is equivalent to get_optimizer_attribute(model, MOI.RawOptimizerAttribute(name)).

See also: set_optimizer_attribute, set_optimizer_attributes.

Example

Return true if the solver has a dual solution in result index result available to query, otherwise return false.

See also dual, shadow_price, and result_count.

Example

Return true if v has a lower bound. If true, the lower bound can be queried with lower_bound.

See also LowerBoundRef, lower_bound, set_lower_bound, delete_lower_bound.

Example

Return true if the variable has a start value set, otherwise return false.

See also: start_value, set_start_value.

Example

Return true if v has a upper bound. If true, the upper bound can be queried with upper_bound.

See also UpperBoundRef, upper_bound, set_upper_bound, delete_upper_bound.

Example

Return true if the solver has a primal solution in result index result available to query, otherwise return false.

See also value and result_count.

Example

Return a String representing the membership to the set set using print mode mode.

Extensions

JuMP extensions may extend this method for new set types to improve the legibility of their printing.

Example

Return a String representing the membership to the set of the constraint constraint using print mode mode.

Return the index of the constraint that corresponds to cr in the MOI backend.

Example

Return the index of the variable that corresponds to v in the MOI backend.

Example

Return true if v is constrained to be binary.

See also BinaryRef, set_binary, unset_binary.

Example

Return true if v is a fixed variable. If true, the fixed value can be queried with fix_value.

See also FixRef, fix_value, fix, unfix.

Example

Return true if v is constrained to be integer.

See also IntegerRef, set_integer, unset_integer.

Example

Return true if x is constrained to be a parameter.

See also ParameterRef, set_parameter_value, parameter_value.

Example

Return true if the model has a feasible primal solution associated with result index result and the termination_status is OPTIMAL (the solver found a global optimum) or LOCALLY_SOLVED (the solver found a local optimum, which may also be the global optimum, but the solver could not prove so).

If allow_local = false, then this function returns true only if the termination_status is OPTIMAL.

If allow_almost = true, then the termination_status may additionally be ALMOST_OPTIMAL or ALMOST_LOCALLY_SOLVED (if allow_local), and the primal_status and dual_status may additionally be NEARLY_FEASIBLE_POINT.

If dual, additionally check that an optimal dual solution is available.

If this function returns false, use termination_status, result_count, primal_status and dual_status to understand what solutions are available (if any).

Example

Return true if con_ref refers to a valid constraint in model.

Example

Return true if variable refers to a valid variable in model.

Example

Return true if x is equal to y after dropping zeros and disregarding the order.

This method is mainly useful for testing, because fallbacks like x == y do not account for valid mathematical comparisons like x[1] + 0 x[2] + 1 == x[1] + 1.

Example

Given an MathOptInterface object x, return the JuMP equivalent.

See also: moi_function.

Example

Return the function of the constraint constraint in the function-in-set form as a AbstractJuMPScalar or Vector{AbstractJuMPScalar}.

Given an MathOptInterface object type T, return the JuMP equivalent.

See also: moi_function_type.

Example

Wrap model in a type so that it can be pretty-printed as text/latex in a notebook like IJulia, or in Documenter.

To render the model, end the cell with latex_formulation(model), or call display(latex_formulation(model)) in to force the display of the model from inside a function.

Provides an iterator over coefficient-variable tuples (a_i::C, x_i::V) in the linear part of the affine expression.

Provides an iterator over tuples (coefficient::C, variable::V) in the linear part of the quadratic expression.

Return a list of tuples of the form (F, S) where F is a JuMP function type and S is an MOI set type such that all_constraints(model, F, S) returns a nonempty list.

Example

Performance considerations

Iterating over the list of function and set types is a type-unstable operation. Consider using a function barrier. See the Performance tips for extensions section of the documentation for more details.

Return the lower bound of a variable. Error if one does not exist.

See also LowerBoundRef, has_lower_bound, set_lower_bound, delete_lower_bound.

Example

Given a JuMP model of a linear program, return an LPMatrixData{T} struct storing data for an equivalent linear program in the form:

where elements in x may be continuous, integer, or binary variables.

Fields

The struct returned by lp_matrix_data has the fields:

Limitations

The models supported by lp_matrix_data are intentionally limited to linear programs.

Example

Given a linear program model with a current optimal basis, return a SensitivityReport object, which maps:

Both tuples are relative, rather than absolute. So given a objective coefficient of 1.0 and a tuple (-0.5, 0.5), the objective coefficient can range between 1.0 - 0.5 an 1.0 + 0.5.

atol is the primal/dual optimality tolerance, and should match the tolerance of the solver used to compute the basis.

Example

Apply f to the coefficients and constant term of an GenericAffExpr a and return a new expression.

See also: map_coefficients_inplace!

Example

Apply f to the coefficients and constant term of an GenericQuadExpr a and return a new expression.

See also: map_coefficients_inplace!

Example

Apply f to the coefficients and constant term of an GenericAffExpr a and update them in-place.

See also: map_coefficients

Example

Apply f to the coefficients and constant term of an GenericQuadExpr a and update them in-place.

See also: map_coefficients

Example

Return the ModelMode of model.

Example

Convert the coefficients and constants of functions and sets in the rhs to the coefficient type value_type(typeof(model)).

Purpose

Creating and adding a constraint is a two-step process. The first step calls build_constraint, and the result of that is passed to add_constraint.

However, because build_constraint does not take the model as an argument, the coefficients and constants of the function or set might be different than value_type(typeof(model)).

Therefore, the result of build_constraint is converted in a call to model_convert before the result is passed to add_constraint.

Return a String representation of model given the mode.

Example

Given a JuMP object x, return the MathOptInterface equivalent.

See also: jump_function.

Example

Return the function of the constraint constraint in the function-in-set form as a MathOptInterface.AbstractFunction.

Given a JuMP object type T, return the MathOptInterface equivalent.

See also: jump_function_type.

Example

Return the set of the constraint constraint in the function-in-set form as a MathOptInterface.AbstractSet.

Returns the MOI set of dimension dim corresponding to the JuMP set s.

Returns the MOI set corresponding to the JuMP set s.

Return the MOI.Name attribute of model's backend, or a default if empty.

Example

Get a variable’s name attribute.

Example

Get a constraint’s name attribute.

Example

If available, returns the total number of branch-and-bound nodes explored during the most recent optimization in a Mixed Integer Program (the MOI.NodeCount attribute).

Throws a MOI.GetAttributeNotAllowed error if the attribute is not implemented by the solver.

Example

Return a string representation of the nonlinear constraint c belonging to model, given the mode.

Return the current value of the MOI attribute MOI.NLPBlockDualStart.

Return a string representation of the nonlinear expression c belonging to model, given the mode.

If model has nonlinear components, return a MOI.Nonlinear.Model, otherwise return nothing.

If force, always return a MOI.Nonlinear.Model, and if one does not exist for the model, create an empty one.

Return the quadratic coefficient associated with variable_1 and variable_2 in constraint after JuMP has normalized the constraint into its standard form.

See also set_normalized_coefficient.

Example

Return the coefficient associated with variable in constraint after JuMP has normalized the constraint into its standard form.

See also set_normalized_coefficient.

Example

Return the right-hand side term of constraint after JuMP has converted the constraint into its normalized form.

See also set_normalized_rhs.

Example

Return the number of constraints currently in the model where the function has type function_type and the set has type set_type.

See also list_of_constraint_types and all_constraints.

Example

Return the number of constraints in model.

If count_variable_in_set_constraints == true, then VariableRef constraints such as VariableRef-in-Integer are included. To count only the number of structural constraints (for example, the rows in the constraint matrix of a linear program), pass count_variable_in_set_constraints = false.

Example

Returns the number of nonlinear constraints associated with the model.

This function counts only the constraints added with @NLconstraint and add_nonlinear_constraint. It does not count GenericNonlinearExpr constraints.

Returns number of variables in model.

Example

Return the dictionary that maps the symbol name of a variable, constraint, or expression to the corresponding object.

Objects are registered to a specific symbol in the macros. For example, @variable(model, x[1:2, 1:2]) registers the array of variables x to the symbol :x.

This method should be defined for any subtype of AbstractModel.

See also: unregister.

Example

Return the best known bound on the optimal objective value after a call to optimize!(model).

For scalar-valued objectives, this function returns a Float64. For vector-valued objectives, it returns a Vector{Float64}.

In the case of a vector-valued objective, this returns the ideal point, that is, the point obtained if each objective was optimized independently.

This function is equivalent to querying the MOI.ObjectiveBound attribute.

Example

Return an object of type F representing the objective function.

Errors if the objective is not convertible to type F.

This function is equivalent to querying the MOI.ObjectiveFunction{F} attribute.

Example

We see with the last two commands that even if the objective function is affine, as it is convertible to a quadratic function, it can be queried as a quadratic function and the result is quadratic.

However, it is not convertible to a variable:

Return a String describing the objective function of the model.

Example

Return the type of the objective function.

This function is equivalent to querying the MOI.ObjectiveFunctionType attribute.

Example

Return the objective sense.

This function is equivalent to querying the MOI.ObjectiveSense attribute.

Example

Return the objective value associated with result index result of the most-recent solution returned by the solver.

For scalar-valued objectives, this function returns a Float64. For vector-valued objectives, it returns a Vector{Float64}.

This function is equivalent to querying the MOI.ObjectiveValue attribute.

See also: result_count.

Example

A function that falls back to ifelse(a, x, y), but when called with a JuMP variables or expression in the first argument, returns a GenericNonlinearExpr.

Example

Return the string that should be printed for the operator op when function_string is called with mime and x.

Example

Converts a sense symbol to a set set such that @constraint(model, func sense_symbol 0) is equivalent to @constraint(model, func in set) for any func::AbstractJuMPScalar.

Example

Once a custom set is defined you can directly create a JuMP constraint with it:

However, there might be an appropriate sign that could be used in order to provide a more convenient syntax:

Note that the whole function is first moved to the right-hand side, then the sign is transformed into a set with zero constant and finally the constant is moved to the set with MOIU.shift_constant.

This function is called on the model whenever two affine expressions are added together without using destructive_add!, and at least one of the two expressions has more than 50 terms.

For the case of Model, if this function is called more than 20,000 times then a warning is generated once.

This method should only be implemented by developers creating JuMP extensions. It should never be called by users of JuMP.