Documentation

OptimizationInequality

Inequality constraints

Description

An OptimizationInequality object contains an inequality constraint in terms of OptimizationVariable objects or OptimizationExpression objects. An inequality constraint uses the comparison operator <= or >=.

A single statement can represent an array of inequalities. For example, you can express the inequalities that each row of a matrix variable x sums to no more than one in this single statement:

constrsum = sum(x,2) <= 1

Use OptimizationInequality objects as constraints in an OptimizationProblem.

Creation

Create an inequality using optimization expressions with the comparison operator <= or >=.

Include inequalities in the Constraints property of an optimization problem by using dot notation.

prob = optimproblem;
x = optimvar(x,4,6);
SumLessThanOne = sum(x,2) <= 1;
prob.Constraints.SumLessThanOne = SumLessThanOne;

You can also create an empty optimization inequality by using optimineq or optimconstr. Typically, you then set the inequalities in a loop. For an example, see Create Inequalities in Loop. However, for the most efficient problem formulation, avoid setting inequalities in loops. See Create Efficient Optimization Problems.

Properties

expand all

Index names, specified as a cell array of strings or character vectors. For information on using index names, see Named Index for Optimization Variables.

Data Types: cell

This property is read-only.

Optimization variables in the object, specified as a structure of OptimizationVariable objects.

Data Types: struct

Object Functions

 infeasibility Constraint violation at a point show Display optimization object write Save optimization object description

Examples

collapse all

Create a 4-by-6 optimization variable matrix named x.

x = optimvar('x',4,6);

Create the inequalities that each row of x sums to no more than one.

constrsum = sum(x,2) <= 1
constrsum =
4×1 Linear OptimizationInequality array with properties:

IndexNames: {{}  {}}
Variables: [1×1 struct] containing 1 OptimizationVariable

See inequality formulation with show.

View the inequalities.

show(constrsum)
(1, 1)

x(1, 1) + x(1, 2) + x(1, 3) + x(1, 4) + x(1, 5) + x(1, 6) <= 1

(2, 1)

x(2, 1) + x(2, 2) + x(2, 3) + x(2, 4) + x(2, 5) + x(2, 6) <= 1

(3, 1)

x(3, 1) + x(3, 2) + x(3, 3) + x(3, 4) + x(3, 5) + x(3, 6) <= 1

(4, 1)

x(4, 1) + x(4, 2) + x(4, 3) + x(4, 4) + x(4, 5) + x(4, 6) <= 1

To include the inequalities in an optimization problem, set a Constraints property to constrsum by using dot notation.

prob = optimproblem;
prob.Constraints.constrsum = constrsum
prob =
OptimizationProblem with properties:

Description: ''
ObjectiveSense: 'minimize'
Variables: [1×1 struct] containing 1 OptimizationVariable
Objective: [0×0 OptimizationExpression]
Constraints: [1×1 struct] containing 1 OptimizationConstraint

See problem formulation with show.

Create the constraint that a two-element variable x must lie in the intersections of a number of disks whose centers and radii are in the arrays centers and radii.

x = optimvar('x',1,2);
centers = [1 -2;3 -4;-2 3];
radii = [6 7 8];
for i = 1:length(constr)
constr(i) = sum((x - centers(i,:)).^2) <= radii(i)^2;
end

View the inequality expressions.

show(constr)
arg_LHS <= arg_RHS

where:

arg1 = zeros([3, 1]);
arg1(1) = sum((x - extraParams{1}).^2);
arg1(2) = sum((x - extraParams{2}).^2);
arg1(3) = sum((x - extraParams{3}).^2);
arg_LHS = arg1(:);
arg1 = zeros([3, 1]);
arg1(1) = 36;
arg1(2) = 49;
arg1(3) = 64;
arg_RHS = arg1(:);

extraParams

Instead of using a loop, you can create the same constraints by using matrix operations on the variables.

constr2 = sum(([x;x;x] - centers).^2,2) <= radii'.^2;

Creating inequalities in a loop can be more time consuming than creating inequalities by using matrix operations.