optimconstr

Crear un arreglo de restricciones de optimización vacío

Sintaxis

constr = optimconstr(N)

constr = optimconstr(cstr)

constr = optimconstr(cstr1,N2,...,cstrk)

constr = optimconstr({cstr1,cstr2,...,cstrk})

constr = optimconstr([N1,N2,...,Nk])

Descripción

Utilice optimconstr para inicializar un conjunto de expresiones de restricción.

Sugerencia

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

constr = optimconstr(N) crea un arreglo de N por 1 de restricciones de optimización vacías. Utilice constr para inicializar un bucle que cree expresiones de restricción.

constr = optimconstr(cstr) crea un arreglo de restricciones de optimización vacías que están indexadas por cstr, un arreglo de celdas de vectores de caracteres o vectores de cadenas.

Si cstr es ncstr, donde ncstr es el número de elementos de cstr, constr también es 1 por ncstr. De lo contrario, constr es ncstr por 1.

constr = optimconstr(cstr1,N2,...,cstrk) o constr = optimconstr({cstr1,cstr2,...,cstrk}) o constr = optimconstr([N1,N2,...,Nk]), para cualquier combinación de los argumentos cstr y N, crea un arreglo de ncstr1 por N2 por ... por ncstrk de restricciones de optimización vacías, donde ncstr es el número de elementos de cstr.

Ejemplos

Crear restricciones en bucle

Cree restricciones para un modelo de inventario. Las existencias al inicio de cada periodo son iguales a las existencias al final del periodo anterior. Durante cada periodo, las existencias aumentan por las buy y disminuyen por las sell. La variable stock son las existencias al final del periodo.

N = 12;
stock = optimvar('stock',N,1,'Type','integer','LowerBound',0);
buy = optimvar('buy',N,1,'Type','integer','LowerBound',0);
sell = optimvar('sell',N,1,'Type','integer','LowerBound',0);
initialstock = 100;

stockbalance = optimconstr(N,1);

for t = 1:N
    if t == 1
        enterstock = initialstock;
    else
        enterstock = stock(t-1);
    end
    stockbalance(t) = stock(t) == enterstock + buy(t) - sell(t);
end

show(stockbalance)

(1, 1)

  -buy(1) + sell(1) + stock(1) == 100

(2, 1)

  -buy(2) + sell(2) - stock(1) + stock(2) == 0

(3, 1)

  -buy(3) + sell(3) - stock(2) + stock(3) == 0

(4, 1)

  -buy(4) + sell(4) - stock(3) + stock(4) == 0

(5, 1)

  -buy(5) + sell(5) - stock(4) + stock(5) == 0

(6, 1)

  -buy(6) + sell(6) - stock(5) + stock(6) == 0

(7, 1)

  -buy(7) + sell(7) - stock(6) + stock(7) == 0

(8, 1)

  -buy(8) + sell(8) - stock(7) + stock(8) == 0

(9, 1)

  -buy(9) + sell(9) - stock(8) + stock(9) == 0

(10, 1)

  -buy(10) + sell(10) - stock(9) + stock(10) == 0

(11, 1)

  -buy(11) + sell(11) - stock(10) + stock(11) == 0

(12, 1)

  -buy(12) + sell(12) - stock(11) + stock(12) == 0

Incluya las restricciones en un problema.

prob = optimproblem;
prob.Constraints.stockbalance = stockbalance;

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

tt = ones(N-1,1);
d = diag(tt,-1); % shift index by -1
stockbalance2 = stock == d*stock + buy - sell;
stockbalance2(1) = stock(1) == initialstock + buy(1) - sell(1);

Muestre las nuevas restricciones para verificar que son las mismas que las restricciones de stockbalance.

show(stockbalance2)

(1, 1)

  -buy(1) + sell(1) + stock(1) == 100

(2, 1)

  -buy(2) + sell(2) - stock(1) + stock(2) == 0

(3, 1)

  -buy(3) + sell(3) - stock(2) + stock(3) == 0

(4, 1)

  -buy(4) + sell(4) - stock(3) + stock(4) == 0

(5, 1)

  -buy(5) + sell(5) - stock(4) + stock(5) == 0

(6, 1)

  -buy(6) + sell(6) - stock(5) + stock(6) == 0

(7, 1)

  -buy(7) + sell(7) - stock(6) + stock(7) == 0

(8, 1)

  -buy(8) + sell(8) - stock(7) + stock(8) == 0

(9, 1)

  -buy(9) + sell(9) - stock(8) + stock(9) == 0

(10, 1)

  -buy(10) + sell(10) - stock(9) + stock(10) == 0

(11, 1)

  -buy(11) + sell(11) - stock(10) + stock(11) == 0

(12, 1)

  -buy(12) + sell(12) - stock(11) + stock(12) == 0

Crear restricciones en un bucle puede llevar más tiempo que crear restricciones mediante operaciones de matriz. No obstante, es menos probable crear una restricción errónea utilizando bucles.

Crear restricciones indexadas en bucle

Cree restricciones indexadas y variables para representar las calorías consumidas en una dieta. Cada comida tiene un límite de calorías diferente.

meals = ["breakfast","lunch","dinner"];
constr = optimconstr(meals);
foods = ["cereal","oatmeal","yogurt","peanut butter sandwich","pizza","hamburger",...
    "salad","steak","casserole","ice cream"];
diet = optimvar('diet',foods,meals,'LowerBound',0);
calories = [200,175,150,450,350,800,150,650,350,300]';
for i = 1:3
    constr(i) = diet(:,i)'*calories <= 250*i;
end

Compruebe la restricción para dinner.

show(constr("dinner"))

  200*diet('cereal', 'dinner') + 175*diet('oatmeal', 'dinner') + 150*diet('yogurt', 'dinner') + 450*diet('peanut butter sandwich', 'dinner') + 350*diet('pizza', 'dinner') + 800*diet('hamburger', 'dinner') + 150*diet('salad', 'dinner') + 650*diet('steak', 'dinner') + 350*diet('casserole', 'dinner') + 300*diet('ice cream', 'dinner') <= 750

Argumentos de entrada

N — Tamaño de la dimensión de restricción

entero positivo

Tamaño de la dimensión de restricción, especificado como entero positivo.

• El tamaño de constr = optimconstr(N) es N por 1.

• El tamaño de constr = optimconstr(N1,N2) es N1 por N2.

• El tamaño de constr = optimconstr(N1,N2,...,Nk) es N1 por N2 por ... por Nk.

Ejemplo: 5

Tipos de datos: double

cstr — Nombres que se desea indexar

arreglo de celdas de vectores de caracteres | vector de cadenas

Nombres que se desea indexar, especificados como un arreglo de celdas de vectores de caracteres o un vector de cadenas.

Nota

cstr no puede ser un escalar de cadena como "Tp", sino que debe ser un vector como ["Tp" "ul"]. Para especificar un único nombre, utilice {'Tp'} o el equivalente cellstr("Tp").

Ejemplo: {'red','orange','green','blue'}

Ejemplo: ["red";"orange";"green";"blue"]

Tipos de datos: string | cell

Argumentos de salida

constr — Restricciones

arreglo OptimizationConstraint vacío

Restricciones, devueltas como un arreglo OptimizationConstraint vacío. Utilice constr para inicializar un bucle que cree expresiones de restricción.

Por ejemplo:

x = optimvar('x',8);
constr = optimconstr(4);
for k = 1:4
    constr(k) = 5*k*(x(2*k) - x(2*k-1)) <= 10 - 2*k;
end

Limitaciones

• Cada expresión de restricción en un problema debe utilizar la misma comparación. Por ejemplo, el siguiente código genera un error, dado que cons1 utiliza la comparación <=, cons2 utiliza la comparación >=, y cons1 y cons2 están en la misma expresión.

  prob = optimproblem;
  x = optimvar('x',2,'LowerBound',0);
  cons1 = x(1) + x(2) <= 10;
  cons2 = 3*x(1) + 4*x(2) >= 2;
  prob.Constraints = [cons1;cons2]; % This line throws an error

  Puede evitar este error utilizando expresiones separadas para las restricciones.

  prob.Constraints.cons1 = cons1;
  prob.Constraints.cons2 = cons2;

Sugerencias

• Por lo general, es más eficiente crear restricciones mediante expresiones vectorizadas que mediante bucles. Consulte Create Efficient Optimization Problems.

• Puede usar optimineq en lugar de optimconstr para crear expresiones de desigualdad. De forma similar, puede usar optimeq en lugar de optimconstr para crear expresiones de igualdad.

Historial de versiones

Introducido en R2017b

Consulte también

optimexpr | OptimizationConstraint | OptimizationExpression | OptimizationVariable | OptimizationProblem | optimineq | optimeq

Temas

• Configuración de optimización basada en problemas
• Flujo de trabajo de optimización basada en problemas