Main Content

La traducción de esta página aún no se ha actualizado a la versión más reciente. Haga clic aquí para ver la última versión en inglés.

OptimizationInequality

Restricciones de desigualdad

Descripción

Un objeto OptimizationInequality contiene una restricción de desigualdad en términos de objetos OptimizationVariable u objetos OptimizationExpression. Una restricción de desigualdad utiliza el operador de comparación <= o >=.

Una declaración única puede representar un arreglo de desigualdades. Por ejemplo, puede expresar las desigualdades de que cada fila de una variable de matriz x no sume más de uno en esta declaración única:

constrsum = sum(x,2) <= 1

Utilice objetos OptimizationInequality como restricciones en un OptimizationProblem.

Sugerencia

Para ver el flujo de trabajo completo, consulte Flujo de trabajo de optimización basada en problemas.

Creación

Cree una desigualdad utilizando expresiones de optimización con el operador de comparación <= o >=.

Incluya desigualdades en la propiedad Constraints de un problema de optimización utilizando notación de puntos.

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

También puede crear una desigualdad de optimización vacía mediante optimineq o optimconstr. Habitualmente, luego se establecen las desigualdades en un bucle. Para ver un ejemplo, consulte Crear desigualdades en un bucle. No obstante, para formular el problema de forma más eficiente, evite establecer desigualdades en bucles. Consulte Create Efficient Optimization Problems.

Propiedades

expandir todo

Nombres de índices, especificados como un arreglo de celdas de cadenas o vectores de caracteres. Para obtener más información sobre cómo utilizar nombres de índices, consulte Named Index for Optimization Variables.

Tipos de datos: cell

Esta propiedad es de solo lectura.

Variables de optimización en el objeto, especificadas como una estructura de objetos OptimizationVariable.

Tipos de datos: struct

Funciones del objeto

infeasibilityConstraint violation at a point
showMuestre información sobre el objeto de optimización
writeSave optimization object description

Ejemplos

contraer todo

Cree una matriz variable de optimización de 4 por 6 llamada x.

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

Cree las desigualdades de que cada fila de x no sume más de uno.

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

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

  See inequality formulation with show.

Visualice las desigualdades.

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

Para incluir las desigualdades en un problema de optimización, establezca una propiedad Constraints en constrsum utilizando notación de puntos.

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

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

  See problem formulation with show.

Cree la restricción en la que una variable x de dos elementos debe encontrarse en las intersecciones de un número de discos cuyos centros y radios están en los arreglos centers y radii.

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

Visualice las expresiones de desigualdad.

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{1}:

     1    -2

  extraParams{2}:

     3    -4

  extraParams{3}:

    -2     3

En lugar de utilizar un bucle, puede crear las mismas restricciones utilizando operaciones de matriz en las variables.

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

Crear desigualdades en un bucle puede llevar más tiempo que crear desigualdades mediante operaciones de matriz.

Historial de versiones

Introducido en R2019b