Main Content

Esta página aún no se ha traducido para esta versión. Puede ver la versión más reciente de esta página en inglés.

intlinprog

Programación lineal de enteros mixtos (MILP)

Descripción

Solucionador de programación lineal de enteros mixtos.

Busca el mínimo de un problema especificado por

minxfTx subject to {x(intcon) are integersAxbAeqx=beqlbxub.

,, INTCON,,,, y son vectores, y y son matrices.fxbbeqlbubAAeq

Puede especificar, INTCON, y como vectores o matrices.flbub Ver.Argumentos de matriz

Nota

intlinprog solo se aplica al enfoque basado en el solucionador. Para ver una explicación de los dos enfoques de optimización, consulte.Elija primero el enfoque basado en problemas o basado en Solver

ejemplo

x = intlinprog(f,intcon,A,b) resuelve min de tal manera que los componentes de in son enteros, y.f'*xxintconA*x ≤ b

x = intlinprog(f,intcon,A,b,Aeq,beq) resuelve el problema anterior, además de satisfacer las restricciones de igualdad.Aeq*x = beq Establecer y si no existen desigualdades.A = []b = []

ejemplo

x = intlinprog(f,intcon,A,b,Aeq,beq,lb,ub) define un conjunto de límites inferior y superior en las variables de diseño, de modo que la solución siempre esté en el intervalo.xlb ≤ x ≤ ub Establecer y si no existen ecualidades.Aeq = []beq = []

ejemplo

x = intlinprog(f,intcon,A,b,Aeq,beq,lb,ub,x0)optimiza utilizando un punto factible inicial.x0 Establecer y si no existen límites.lb = []ub = []

ejemplo

x = intlinprog(f,intcon,A,b,Aeq,beq,lb,ub,x0,options) minimiza el uso de las opciones de optimización especificadas en.Opciones Se usa para establecer estas opciones.optimoptions Establecer si no existe ningún punto inicial.x0 = []

ejemplo

x = intlinprog(problem) utiliza una estructura para encapsular todas las entradas del solucionador.problem Puede importar una estructura desde un archivo MPS utilizando.problemmpsread También puede crear una estructura a partir de un objeto mediante.problemOptimizationProblemprob2struct

ejemplo

[x,fval,exitflag,output] = intlinprog(___), para los argumentos de entrada descritos anteriormente, devuelve, un valor que describe la condición de salida y una estructura que contiene información sobre el proceso de optimización.fval = f'*xexitflagoutput

Ejemplos

contraer todo

Resolver el problema

<math display="block">
<mrow>
<munder>
<mrow>
<mrow>
<mrow>
<mi mathvariant="normal">min</mi>
</mrow>
</mrow>
</mrow>
<mrow>
<mi>x</mi>
</mrow>
</munder>
<mn>8</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mrow>
<mstyle mathvariant="normal">
<mrow>
<mrow>
<mspace width="0.5em"></mspace>
<mi>s</mi>
<mi>u</mi>
<mi>b</mi>
<mi>j</mi>
<mi>e</mi>
<mi>c</mi>
<mi>t</mi>
<mspace width="0.5em"></mspace>
<mi>t</mi>
<mi>o</mi>
<mspace width="0.5em"></mspace>
</mrow>
</mrow>
</mstyle>
</mrow>
<mrow>
<mo>{</mo>
<mrow>
<mtable columnalign="left left left left left left left left left left left left left left left left left left left left">
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mrow>
<mstyle mathvariant="normal">
<mrow>
<mrow>
<mspace width="0.5em"></mspace>
<mi>i</mi>
<mi>s</mi>
<mspace width="0.5em"></mspace>
<mi>a</mi>
<mi>n</mi>
<mspace width="0.5em"></mspace>
<mi>i</mi>
<mi>n</mi>
<mi>t</mi>
<mi>e</mi>
<mi>g</mi>
<mi>e</mi>
<mi>r</mi>
</mrow>
</mrow>
</mstyle>
</mrow>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mn>2</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo></mo>
<mo>-</mo>
<mn>1</mn>
<mn>4</mn>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mo>-</mo>
<mn>4</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>-</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo></mo>
<mo>-</mo>
<mn>3</mn>
<mn>3</mn>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mn>2</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo></mo>
<mn>2</mn>
<mn>0</mn>
<mo>.</mo>
</mrow>
</mrow>
</mtd>
</mtr>
</mtable>
</mrow>
</mrow>
</mrow>
</math>

Escriba el vector de función objetivo y el vector de variables enteras.

f = [8;1]; intcon = 2;

Convierta todas las desigualdades en la forma multiplicando las desigualdades "mayores que".A*x <= b-1

A = [-1,-2;     -4,-1;     2,1]; b = [14;-33;20];

Llamar.intlinprog

x = intlinprog(f,intcon,A,b)
LP:                Optimal objective value is 59.000000.                                               Optimal solution found.  Intlinprog stopped at the root node because the objective value is within a gap tolerance of the optimal value, options.AbsoluteGapTolerance = 0 (the default value). The intcon variables are integer within tolerance, options.IntegerTolerance = 1e-05 (the default value). 
x = 2×1

    6.5000
    7.0000

Resolver el problema

<math display="block">
<mrow>
<munder>
<mrow>
<mrow>
<mrow>
<mi mathvariant="normal">min</mi>
</mrow>
</mrow>
</mrow>
<mrow>
<mi>x</mi>
</mrow>
</munder>
<mrow>
<mo>(</mo>
<mrow>
<mo>-</mo>
<mn>3</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>-</mo>
<mn>2</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo>-</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>3</mn>
</mrow>
</msub>
</mrow>
</mrow>
<mo>)</mo>
</mrow>
<mrow>
<mstyle mathvariant="normal">
<mrow>
<mrow>
<mspace width="0.5em"></mspace>
<mi>s</mi>
<mi>u</mi>
<mi>b</mi>
<mi>j</mi>
<mi>e</mi>
<mi>c</mi>
<mi>t</mi>
<mspace width="0.5em"></mspace>
<mi>t</mi>
<mi>o</mi>
</mrow>
</mrow>
</mstyle>
</mrow>
<mrow>
<mo>{</mo>
<mrow>
<mtable columnalign="left left left left left left left left left left left left left left left left left left left left">
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>3</mn>
</mrow>
</msub>
</mrow>
<mrow>
<mstyle mathvariant="normal">
<mrow>
<mrow>
<mspace width="0.5em"></mspace>
<mi>b</mi>
<mi>i</mi>
<mi>n</mi>
<mi>a</mi>
<mi>r</mi>
<mi>y</mi>
</mrow>
</mrow>
</mstyle>
</mrow>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>,</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo></mo>
<mn>0</mn>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>3</mn>
</mrow>
</msub>
</mrow>
<mo></mo>
<mn>7</mn>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mn>4</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mn>2</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>3</mn>
</mrow>
</msub>
</mrow>
<mo>=</mo>
<mn>1</mn>
<mn>2</mn>
<mo>.</mo>
</mrow>
</mrow>
</mtd>
</mtr>
</mtable>
</mrow>
</mrow>
</mrow>
</math>

Escriba el vector de función objetivo y el vector de variables enteras.

f = [-3;-2;-1]; intcon = 3;

Escriba las restricciones de desigualdad lineales.

A = [1,1,1]; b = 7;

Escriba las restricciones de igualdad lineales.

Aeq = [4,2,1]; beq = 12;

Escriba las restricciones enlazadas.

lb = zeros(3,1); ub = [Inf;Inf;1]; % Enforces x(3) is binary

Llamar.intlinprog

x = intlinprog(f,intcon,A,b,Aeq,beq,lb,ub)
LP:                Optimal objective value is -12.000000.                                              Optimal solution found.  Intlinprog stopped at the root node because the objective value is within a gap tolerance of the optimal value, options.AbsoluteGapTolerance = 0 (the default value). The intcon variables are integer within tolerance, options.IntegerTolerance = 1e-05 (the default value). 
x = 3×1

         0
    5.5000
    1.0000

Compare el número de pasos para resolver un problema de programación de enteros con y sin un punto factible inicial. El problema tiene ocho variables, cuatro restricciones de igualdad lineales y tiene todas las variables restringidas para ser positivas.

Defina la matriz de restricción de igualdad lineal y el vector.

Aeq = [22    13    26    33    21     3    14    26     39    16    22    28    26    30    23    24     18    14    29    27    30    38    26    26     41    26    28    36    18    38    16    26]; beq = [ 7872        10466        11322        12058];

Establezca límites inferiores que restrinjan que todas las variables sean no negativas.

N = 8; lb = zeros(N,1);

Especifique que todas las variables tienen un valor entero.

intcon = 1:N;

Establezca el vector de función objetivo.f

f = [2    10    13    17     7     5     7     3];

Resuelva el problema sin utilizar un punto inicial y examine la visualización para ver el número de nodos ramifican y enlazados.

[x1,fval1,exitflag1,output1] = intlinprog(f,intcon,[],[],Aeq,beq,lb);
LP:                Optimal objective value is 1554.047531.                                            Cut Generation:    Applied 8 strong CG cuts.                                                                            Lower bound is 1591.000000.                                                        Branch and Bound:     nodes     total   num int        integer       relative                                           explored  time (s)  solution           fval        gap (%)                                             10000      1.96         0              -              -                                              18188      3.07         1   2.906000e+03   4.509804e+01                                              22039      3.80         2   2.073000e+03   2.270974e+01                                              24105      4.13         3   1.854000e+03   9.973046e+00                                              24531      4.18         3   1.854000e+03   1.347709e+00                                              24701      4.21         3   1.854000e+03   0.000000e+00                                            Optimal solution found.  Intlinprog stopped because the objective value is within a gap tolerance of the optimal value, options.AbsoluteGapTolerance = 0 (the default value). The intcon variables are integer within tolerance, options.IntegerTolerance = 1e-05 (the default value). 

Para la comparación, busque la solución utilizando un punto factible inicial.

x0 = [8 62 23 103 53 84 46 34]; [x2,fval2,exitflag2,output2] = intlinprog(f,intcon,[],[],Aeq,beq,lb,[],x0);
LP:                Optimal objective value is 1554.047531.                                            Cut Generation:    Applied 8 strong CG cuts.                                                                            Lower bound is 1591.000000.                                                                          Relative gap is 59.20%.                                                           Branch and Bound:     nodes     total   num int        integer       relative                                           explored  time (s)  solution           fval        gap (%)                                              3627      0.72         2   2.154000e+03   2.593968e+01                                               5844      1.00         3   1.854000e+03   1.180593e+01                                               6204      1.05         3   1.854000e+03   1.455526e+00                                               6400      1.06         3   1.854000e+03   0.000000e+00                                            Optimal solution found.  Intlinprog stopped because the objective value is within a gap tolerance of the optimal value, options.AbsoluteGapTolerance = 0 (the default value). The intcon variables are integer within tolerance, options.IntegerTolerance = 1e-05 (the default value). 
  • Sin un punto inicial, tomó alrededor de 30.000 pasos de bifurcación y encuadernado.intlinprog

  • Usando un punto inicial, tomó alrededor de 5.000 pasos.intlinprog

Dar un punto inicial no siempre ayuda. Para este problema, dar un punto inicial ahorra tiempo y pasos computacionales. Sin embargo, para algunos problemas, dar un punto inicial puede hacer que tome más pasos.intlinprog

Resolver el problema

<math display="block">
<mrow>
<munder>
<mrow>
<mrow>
<mrow>
<mi mathvariant="normal">min</mi>
</mrow>
</mrow>
</mrow>
<mrow>
<mi>x</mi>
</mrow>
</munder>
<mrow>
<mo>(</mo>
<mrow>
<mo>-</mo>
<mn>3</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>-</mo>
<mn>2</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo>-</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>3</mn>
</mrow>
</msub>
</mrow>
</mrow>
<mo>)</mo>
</mrow>
<mrow>
<mstyle mathvariant="normal">
<mrow>
<mrow>
<mspace width="0.5em"></mspace>
<mi>s</mi>
<mi>u</mi>
<mi>b</mi>
<mi>j</mi>
<mi>e</mi>
<mi>c</mi>
<mi>t</mi>
<mspace width="0.5em"></mspace>
<mi>t</mi>
<mi>o</mi>
</mrow>
</mrow>
</mstyle>
</mrow>
<mrow>
<mo>{</mo>
<mrow>
<mtable columnalign="left left left left left left left left left left left left left left left left left left left left">
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>3</mn>
</mrow>
</msub>
</mrow>
<mrow>
<mstyle mathvariant="normal">
<mrow>
<mrow>
<mspace width="0.5em"></mspace>
<mi>b</mi>
<mi>i</mi>
<mi>n</mi>
<mi>a</mi>
<mi>r</mi>
<mi>y</mi>
</mrow>
</mrow>
</mstyle>
</mrow>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>,</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo></mo>
<mn>0</mn>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>3</mn>
</mrow>
</msub>
</mrow>
<mo></mo>
<mn>7</mn>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mn>4</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mn>2</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>3</mn>
</mrow>
</msub>
</mrow>
<mo>=</mo>
<mn>1</mn>
<mn>2</mn>
</mrow>
</mrow>
</mtd>
</mtr>
</mtable>
</mrow>
</mrow>
</mrow>
</math>

sin mostrar la visualización iterativa.

Especifique las entradas del solucionador.

f = [-3;-2;-1]; intcon = 3; A = [1,1,1]; b = 7; Aeq = [4,2,1]; beq = 12; lb = zeros(3,1); ub = [Inf;Inf;1]; % enforces x(3) is binary x0 = [];

No especifique ninguna visualización.

options = optimoptions('intlinprog','Display','off');

Ejecute el solucionador.

x = intlinprog(f,intcon,A,b,Aeq,beq,lb,ub,x0,options)
x = 3×1

         0
    5.5000
    1.0000

En este ejemplo se muestra cómo configurar un problema mediante el enfoque basado en problemas y, a continuación, resolverlo mediante el enfoque basado en el solucionador. El problema es

<math display="block">
<mrow>
<munder>
<mrow>
<mrow>
<mrow>
<mi mathvariant="normal">min</mi>
</mrow>
</mrow>
</mrow>
<mrow>
<mi>x</mi>
</mrow>
</munder>
<mrow>
<mo>(</mo>
<mrow>
<mo>-</mo>
<mn>3</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>-</mo>
<mn>2</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo>-</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>3</mn>
</mrow>
</msub>
</mrow>
</mrow>
<mo>)</mo>
</mrow>
<mrow>
<mstyle mathvariant="normal">
<mrow>
<mrow>
<mspace width="0.5em"></mspace>
<mi>s</mi>
<mi>u</mi>
<mi>b</mi>
<mi>j</mi>
<mi>e</mi>
<mi>c</mi>
<mi>t</mi>
<mspace width="0.5em"></mspace>
<mi>t</mi>
<mi>o</mi>
<mspace width="0.5em"></mspace>
</mrow>
</mrow>
</mstyle>
</mrow>
<mrow>
<mo>{</mo>
<mrow>
<mtable columnalign="left left left left left left left left left left left left left left left left left left left left">
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>3</mn>
</mrow>
</msub>
</mrow>
<mrow>
<mstyle mathvariant="normal">
<mrow>
<mrow>
<mspace width="0.5em"></mspace>
<mi>b</mi>
<mi>i</mi>
<mi>n</mi>
<mi>a</mi>
<mi>r</mi>
<mi>y</mi>
</mrow>
</mrow>
</mstyle>
</mrow>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>,</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo></mo>
<mn>0</mn>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>3</mn>
</mrow>
</msub>
</mrow>
<mo></mo>
<mn>7</mn>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mn>4</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mn>2</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>3</mn>
</mrow>
</msub>
</mrow>
<mo>=</mo>
<mn>1</mn>
<mn>2</mn>
</mrow>
</mrow>
</mtd>
</mtr>
</mtable>
</mrow>
</mrow>
</mrow>
</math>

Cree un objeto denominado para representar este problema.OptimizationProblemprob Para especificar una variable binaria, cree una variable de optimización con un tipo entero, un límite inferior de 0 y un límite superior de 1.

x = optimvar('x',2,'LowerBound',0); xb = optimvar('xb','LowerBound',0,'UpperBound',1,'Type','integer'); prob = optimproblem('Objective',-3*x(1)-2*x(2)-xb); cons1 = sum(x) + xb <= 7; cons2 = 4*x(1) + 2*x(2) + xb == 12; prob.Constraints.cons1 = cons1; prob.Constraints.cons2 = cons2;

Convierta el objeto problemático en una estructura problemática.

problem = prob2struct(prob);

Resuelva la estructura del problema resultante.

[sol,fval,exitflag,output] = intlinprog(problem)
LP:                Optimal objective value is -12.000000.                                              Optimal solution found.  Intlinprog stopped at the root node because the objective value is within a gap tolerance of the optimal value, options.AbsoluteGapTolerance = 0 (the default value). The intcon variables are integer within tolerance, options.IntegerTolerance = 1e-05 (the default value). 
sol = 3×1

         0
    5.5000
    1.0000

fval = -12 
exitflag = 1 
output = struct with fields:
        relativegap: 0
        absolutegap: 0
      numfeaspoints: 1
           numnodes: 0
    constrviolation: 0
            message: 'Optimal solution found....'

Ambos y son de valor binario.sol(1)sol(3) ¿Qué valor corresponde a la variable de optimización binaria?xb

prob.Variables
ans = struct with fields:
     x: [2x1 optim.problemdef.OptimizationVariable]
    xb: [1x1 optim.problemdef.OptimizationVariable]

La variable aparece en último en la pantalla, por lo que corresponde a.xbVariablesxbsol(3) = 1 Ver.Algoritmos

Llame con más salidas para ver los detalles y el proceso de la solución.intlinprog

El objetivo es resolver el problema

<math display="block">
<mrow>
<munder>
<mrow>
<mrow>
<mrow>
<mi mathvariant="normal">min</mi>
</mrow>
</mrow>
</mrow>
<mrow>
<mi>x</mi>
</mrow>
</munder>
<mrow>
<mo>(</mo>
<mrow>
<mo>-</mo>
<mn>3</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>-</mo>
<mn>2</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo>-</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>3</mn>
</mrow>
</msub>
</mrow>
</mrow>
<mo>)</mo>
</mrow>
<mrow>
<mstyle mathvariant="normal">
<mrow>
<mrow>
<mspace width="0.5em"></mspace>
<mi>s</mi>
<mi>u</mi>
<mi>b</mi>
<mi>j</mi>
<mi>e</mi>
<mi>c</mi>
<mi>t</mi>
<mspace width="0.5em"></mspace>
<mi>t</mi>
<mi>o</mi>
</mrow>
</mrow>
</mstyle>
</mrow>
<mrow>
<mo>{</mo>
<mrow>
<mtable columnalign="left left left left left left left left left left left left left left left left left left left left">
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>3</mn>
</mrow>
</msub>
</mrow>
<mrow>
<mstyle mathvariant="normal">
<mrow>
<mrow>
<mspace width="0.5em"></mspace>
<mi>b</mi>
<mi>i</mi>
<mi>n</mi>
<mi>a</mi>
<mi>r</mi>
<mi>y</mi>
</mrow>
</mrow>
</mstyle>
</mrow>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>,</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo></mo>
<mn>0</mn>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>3</mn>
</mrow>
</msub>
</mrow>
<mo></mo>
<mn>7</mn>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mn>4</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mn>2</mn>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
<mo>+</mo>
<mrow>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>3</mn>
</mrow>
</msub>
</mrow>
<mo>=</mo>
<mn>1</mn>
<mn>2</mn>
<mo>.</mo>
</mrow>
</mrow>
</mtd>
</mtr>
</mtable>
</mrow>
</mrow>
</mrow>
</math>

Especifique las entradas del solucionador.

f = [-3;-2;-1]; intcon = 3; A = [1,1,1]; b = 7; Aeq = [4,2,1]; beq = 12; lb = zeros(3,1); ub = [Inf;Inf;1]; % enforces x(3) is binary

Llame con todas las salidas.intlinprog

[x,fval,exitflag,output] = intlinprog(f,intcon,A,b,Aeq,beq,lb,ub)
LP:                Optimal objective value is -12.000000.                                              Optimal solution found.  Intlinprog stopped at the root node because the objective value is within a gap tolerance of the optimal value, options.AbsoluteGapTolerance = 0 (the default value). The intcon variables are integer within tolerance, options.IntegerTolerance = 1e-05 (the default value). 
x = 3×1

         0
    5.5000
    1.0000

fval = -12 
exitflag = 1 
output = struct with fields:
        relativegap: 0
        absolutegap: 0
      numfeaspoints: 1
           numnodes: 0
    constrviolation: 0
            message: 'Optimal solution found....'

La estructura de salida se muestra.numnodes0 Esto significa resolver el problema antes de la bifurcación.intlinprog Esta es una indicación de que el resultado es confiable. Además, los campos y son.absolutegaprelativegap0 Esta es otra indicación de que el resultado es confiable.

Argumentos de entrada

contraer todo

Vector de coeficiente, especificado como un vector real o una matriz real. El vector de coeficiente representa la función objetiva.f'*x La notación asume que es un vector de columna, pero usted es libre de utilizar un vector de fila o una matriz.f Internamente, convierte al vector de columna.linprogff(:)

Si se especifica, intenta encontrar un punto factible sin intentar minimizar una función objetiva.f = []intlinprog

Ejemplo: f = [4;2;-1.7];

Tipos de datos: double

Vector de restricciones de enteros, especificado como un vector de enteros positivos. Los valores en indican los componentes de la variable de decisión que son de valores enteros. tiene valores desde.intconxintcon1numel(f)

también puede ser una matriz.intcon Internamente, convierte una matriz en el vector.intlinprogintconintcon(:)

Ejemplo: significa, y sólo toman valores enteros.intcon = [1,2,7]x(1)x(2)x(7)

Tipos de datos: double

Matriz de restricción de desigualdad lineal, especificada como una matriz de dobles. representa los coeficientes lineales de las restricciones ≤. tiene el tamaño por, donde está el número de restricciones y =.AA*x  bAMNMNnumel(f) Para ahorrar memoria, puede ser escaso.A

Ejemplo: significa tres desigualdades lineales (tres filas) para dos variables de decisión (dos columnas).A = [4,3;2,0;4,-1];

Tipos de datos: double

Vector de restricción de desigualdad lineal, especificado como vector de dobles. representa el vector constante en las restricciones ≤. tiene longitud, donde está-por-.bA*x  bbMAMN

Ejemplo: [4,0]

Tipos de datos: double

Matriz de restricción de igualdad lineal, especificada como una matriz de dobles. representa los coeficientes lineales en las restricciones =. tiene el tamaño por, donde está el número de restricciones y =.AeqAeq*x  beqAeqMeqNMeqNnumel(f) Para ahorrar memoria, puede ser escaso.Aeq

Ejemplo: significa tres desigualdades lineales (tres filas) para dos variables de decisión (dos columnas).A = [4,3;2,0;4,-1];

Tipos de datos: double

Vector de restricción de igualdad lineal, especificado como vector de dobles. representa el vector constante en las restricciones =. tiene longitud, donde está-por-.beqAeq*x  beqbeqMeqAeqMeqN

Ejemplo: [4,0]

Tipos de datos: double

Límites inferiores, especificados como vector o array de dobles. representa los límites inferiores elementwise en ≤ ≤.lblb  x  ub

Internamente, convierte una matriz en el vector.intlinproglblb(:)

Ejemplo: Significa.lb = [0;-Inf;4]x(1) ≥ 0x(3) ≥ 4

Tipos de datos: double

Límites superiores, especificados como un vector o una matriz de dobles. representa los límites superiores elementwise en ≤ ≤.ublb  x  ub

Internamente, convierte una matriz en el vector.intlinprogubub(:)

Ejemplo: Significa.ub = [Inf;4;10]x(2) ≤ 4x(3) ≤ 10

Tipos de datos: double

Punto inicial, especificado como una matriz real. El número de elementos en es el mismo que el número de elementos de, cuando existe.x0ff De lo contrario, el número es el mismo que el número de columnas de o.AAeq Internamente, el solucionador convierte una matriz en un vector.x0x0(:)

Proporcionar puede cambiar la cantidad de tiempo que tarda en converger.x0intlinprog Es difícil predecir cómo afecta al solucionador.x0 Para sugerencias sobre el uso apropiado con, vea.Heuristicsx0Consejos

debe ser factible con respecto a todas las restricciones.x0 Si no es factible, los errores del solucionador.x0 Si usted no tiene un factible, establecer.x0x0 = []

Ejemplo: x0 = 100*rand(size(f))

Tipos de datos: double

Opciones para, especificadas como la salida de.intlinprogoptimoptions

Algunas opciones están ausentes en la pantalla.optimoptions Estas opciones aparecen en cursiva en la tabla siguiente. Para obtener más información, consulte.Ver opciones

OpciónDescripciónPredeterminado
AbsoluteGapTolerance

Real no negativo. se detiene si la diferencia entre los límites superior () y inferior () calculados internamente en la función objetiva es menor o igual a:intlinprogULAbsoluteGapTolerance

.U – L <= AbsoluteGapTolerance

0
BranchRule

Regla para elegir el componente para la bifurcación:

  • — El componente fraccionario con un pseudocoste máximo.'maxpscost' Ver.Rama y encuadernado

  • — El componente fraccionario con un pseudocoste máximo y una estimación más precisa de pseudocoste que en.'strongpscost''maxpscost' Ver.Rama y encuadernado

  • — El componente fraccionario con un pseudocoste máximo y una estimación aún más precisa de pseudocoste que en.'reliability''strongpscost' Ver.Rama y encuadernado

  • — El componente cuya parte fraccionaria está más cerca.'mostfractional'1/2

  • — El componente fraccionario con un componente máximo correspondiente en el valor absoluto del vector objetivo.'maxfun'f

'reliability'
ConstraintToleranceReal de a través de esa es la máxima discrepancia que las restricciones lineales pueden tener y todavía se consideran satisfechos. no es un criterio de detención.1e-91e-3ConstraintTolerance1e-4
CutGeneration

Nivel de generación de corte (ver):Generación de corte

  • — Sin cortes.'none' Hace irrelevante.CutMaxIterations

  • — Generación de corte normal.'basic'

  • — Utilice más tipos de corte.'intermediate'

  • — Utilice la mayoría de los tipos de corte.'advanced'

'basic'
CutMaxIterationsNúmero de pasadas a través de todos los métodos de generación de cortes antes de entrar en la fase de bifurcación y encuadernado, un entero a través de.150 Deshabilite la generación de cortes estableciendo la opción en.CutGeneration'none'10
Display

Nivel de visualización (ver):Visualización iterativa

  • o — sin visualización iterativa'off''none'

  • — Mostrar sólo los valores finales'final'

  • : Muestra la visualización iterativa'iter'

'iter'
Heuristics

Algoritmo para buscar puntos factibles (véase):Heurística para encontrar soluciones factibles

  • 'basic'

  • 'intermediate'

  • 'advanced'

  • 'rss'

  • 'rins'

  • 'round'

  • 'diving'

  • 'rss-diving'

  • 'rins-diving'

  • 'round-diving'

  • 'none'

'basic'
HeuristicsMaxNodesEl entero estrictamente positivo que limita el número de nodos puede explorar en su búsqueda ramificación y enlazada de puntos factibles.intlinprog Se aplica sólo a y.'rss''rins' Ver.Heurística para encontrar soluciones factibles50
IntegerPreprocess

Tipos de preprocesamiento de enteros (véase):El preprocesamiento de programa entero mixto

  • — Utilice muy pocos pasos de preprocesamiento de enteros.'none'

  • : Utilice un número moderado de pasos de preprocesamiento de enteros.'basic'

  • : Utilice todos los pasos de preprocesamiento enteros disponibles.'advanced'

'basic'
IntegerToleranceReal desde el medio, donde la desviación máxima del entero que un componente de la solución puede tener y todavía se considera un entero. no es un criterio de detención.1e-61e-3xIntegerTolerance1e-5
LPMaxIterationsEntero estrictamente positivo, el número máximo de iteraciones del algoritmo simplex por nodo durante el proceso de bifurcación y enlazado.

max(3e4, 10*(numberOfEqualities + numberOfInequalities + numberOfVariables))

En esta expresión, significa el número de filas de, significa el número de filas de, y significa el número de elementos de.numberOfEqualitiesAeqnumberOfInequalitiesAnumberOfVariablesf

LPOptimalityToleranceReal no negativo cuando los costos reducidos deben exceder para que una variable sea tomada en la base.LPOptimalityTolerance1e-7
LPPreprocess

Tipo de preprocesado para la solución al programa lineal relajado (ver):El preprocesamiento lineal del programa

  • — Sin preprocesamiento.'none'

  • — Utilice el preprocesamiento.'basic'

'basic'
MaxNodesEntero positivo estrictamente que es el número máximo de nodos explora en su proceso de bifurcación y enlazado.intlinprog1e7
MaxFeasiblePointsEntero estrictamente positivo. se detiene si encuentra puntos de enteros factibles.intlinprogMaxFeasiblePointsInf
MaxTimePositivo real que es el tiempo máximo en segundos que se ejecuta.intlinprog7200
NodeSelection

Elija el nodo que desea explorar a continuación.

  • — Mejor proyección.'simplebestproj' Ver.Rama y encuadernado

  • — Explore el nodo con la función de objetivo mínimo.'minobj'

  • : Explore el nodo con la suma mínima de inbilidades de enteros.'mininfeas' Ver.Rama y encuadernado

'simplebestproj'
ObjectiveCutOffRealmente mayor que.-Inf Durante el cálculo de bifurcación y enlazado, descarta cualquier nodo en el que la solución de programación lineal tenga un valor objetivo superior.intlinprogObjectiveCutOffInf
ObjectiveImprovementThresholdReal no negativo. cambia la solución factible actual solo cuando localiza otra con un valor de función objetivo que es al menos inferior:intlinprogObjectiveImprovementThreshold (fold – fnew)/(1 + |fold|) > ObjectiveImprovementThreshold.0
OutputFcn

Especifique una o varias funciones a las que llama una función de optimización en eventos como, un identificador de función o una matriz de celdas de identificadores de función.'savemilpsolutions' Para las funciones de salida personalizadas, pase los identificadores de función.

  • recopila los puntos de enteros factibles de la matriz en el área de trabajo, donde cada columna es un punto entero factible.'savemilpsolutions'xIntSol

Para obtener información sobre cómo escribir una función de salida personalizada, consulte.Función de salida y sintaxis de función de trazadointlinprog

[]
PlotFcn

Traza varias medidas de progreso mientras se ejecuta el algoritmo; seleccionar de parcelas predefinidas o escribir las suyas propias. Pass, un identificador de función o una matriz de celdas de identificadores de función.'optimplotmilp' Para las funciones de trazado personalizadas, pase los identificadores de función. El valor predeterminado es None ():[]

  • traza los límites superior e inferior calculados internamente en el valor objetivo de la solución.'optimplotmilp'

Para obtener información sobre cómo escribir una función de trazado personalizada, consulte.Función de salida y sintaxis de función de trazadointlinprog

[]
RelativeGapTolerance

Real desde el pasado. se detiene si la diferencia relativa entre los límites superior () y inferior () calculados internamente en la función objetiva es menor o igual a:01intlinprogULRelativeGapTolerance

.(U – L) / (abs(U) + 1) <= RelativeGapTolerance

modifica automáticamente la tolerancia para grandes magnitudes:intlinprogL

tolerancia =min(1/(1+|L|), RelativeGapTolerance)

Nota

Mientras se especifica como un número decimal, la visualización iterativa y el informe de la brecha en porcentaje, lo que significa 100 veces la brecha relativa medida.RelativeGapToleranceoutput.relativegap Si el mensaje de salida se refiere a la brecha relativa, este valor es el intervalo relativo medido, no un porcentaje.

1e-4
RootLPAlgorithm

Algoritmo para la resolución de programas lineales:

  • — Algoritmo simplex dual'dual-simplex'

  • — Algoritmo simplex primitivo'primal-simplex'

'dual-simplex'
RootLPMaxIterationsEntero no negativo que es el número máximo de iteraciones del algoritmo simplex para resolver el problema de programación lineal inicial.

max(3e4, 10*(numberOfEqualities + numberOfInequalities + numberOfVariables))

En esta expresión, significa el número de filas de, significa el número de filas de, y significa el número de elementos de.numberOfEqualitiesAeqnumberOfInequalitiesAnumberOfVariablesf

Ejemplo: options = optimoptions('intlinprog','MaxTime',120)

Estructura que encapsula las entradas y opciones, especificadas con los siguientes campos.

fVector que representa el objetivo (obligatorio)f'*x
intconVector que indica variables que toman valores enteros (obligatorios)
AineqMatriz en las restricciones de desigualdad lineales ≤Aineq*x  bineq

bineq

Vector en las restricciones de desigualdad lineal ≤Aineq*x  bineq

Aeq

Matriz en las restricciones de igualdad linealAeq*x = beq

beq

Vector en las restricciones de igualdad linealAeq*x = beq
lbVector de los límites inferiores
ubVector de los límites superiores
x0Punto factible inicial
solverrequiere'intlinprog'

Opciones

Opciones creadas con (obligatorio)optimoptions

Debe especificar al menos estos campos en la estructura del problema. Otros campos son opcionales:

  • f

  • intcon

  • solver

  • Opciones

Ejemplo: problem.f = [1,2,3];
problem.intcon = [2,3];
problem.options = optimoptions('intlinprog');
problem.Aineq = [-3,-2,-1];
problem.bineq = -20;
problem.lb = [-6.1,-1.2,7.3];
problem.solver = 'intlinprog';

Tipos de datos: struct

Argumentos de salida

contraer todo

Solución, devuelta como un vector que minimiza sujeto a todos los límites, restricciones de enteros y restricciones lineales.f'*x

Cuando un problema es inviable o ilimitado, es.x[]

Valor de objetivo, devuelto como el valor escalar en la solución.f'*xx

Cuando un problema es inviable o ilimitado, es.fval[]

Condición de detención del algoritmo, devuelta como un entero que identifica la razón por la que el algoritmo se detuvo. A continuación se enumeran los valores y los motivos correspondientes detenidos.exitflagintlinprog

3

La solución es factible con respecto a la tolerancia relativa, pero no es factible con respecto a la tolerancia absoluta.ConstraintTolerance

2

detenido prematuramente.intlinprog Se encontró un punto entero factible.

1

convergieron en la solución.intlinprogx

0

detenido prematuramente.intlinprog No se encontró un punto entero factible.

-1

detenido por una función de salida o una función de trazado.intlinprog

-2

No se encontró un punto factible.

-3

Root problema de LP es ilimitado.

-9

Solver perdió viabilidad.

El mensaje de salida puede dar información más detallada sobre la razón detenida, por ejemplo, exceder una tolerancia.intlinprog

Exitflags y se relacionan con soluciones que tienen grandes inbilidades.3-9 Estos suelen surgir de matrices de restricciones lineales que tienen un número de condición grande, o problemas que tienen grandes componentes de la solución. Para corregir estos problemas, intente escalar las matrices de coeficiente, elimine las restricciones lineales redundantes o dé límites más estrictos a las variables.

Resumen del proceso de solución, devuelto como una estructura que contiene información sobre el proceso de optimización.

relativegap

Diferencia porcentual relativa entre los límites superior () e inferior () de la función objetiva que calcula en su algoritmo de bifurcación y enlazado.ULintlinprog

relativegap = 100*(U - L) / (abs(U) + 1)

Si.intcon = []relativegap = []

Nota

Mientras se especifica como un número decimal, la visualización iterativa y el informe de la brecha en porcentaje, lo que significa 100 veces la brecha relativa medida.RelativeGapToleranceoutput.relativegap Si el mensaje de salida se refiere a la brecha relativa, este valor es el intervalo relativo medido, no un porcentaje.

absolutegap

Diferencia entre los límites superior e inferior de la función objetiva que calcula en su algoritmo de bifurcación y enlazado.intlinprog

Si.intcon = []absolutegap = []

numfeaspoints

Número de puntos enteros factibles encontrados.

Si.intcon = []numfeaspoints = [] Además, si el problema inicial relajado es inviable,.numfeaspoints = []

numnodes

Número de nodos en el algoritmo de bifurcación y enlazado. Si la solución se encontró durante el preprocesamiento o durante los cortes iniciales,.numnodes = 0

Si.intcon = []numnodes = []

constrviolation

Infracción de restricción positiva para las restricciones infringidas.

constrviolation = max([0; norm(Aeq*x-beq, inf); (lb-x); (x-ub); (Ai*x-bi)])

message

Mensaje de salida.

Limitaciones

  • A menudo, algunos componentes supuestamente con valores enteros de la solución no son exactamente enteros. considera enteros todos los valores de la solución dentro de un entero.x(intCon)intlinprogIntegerTolerance

    Para redondear todos los enteros supuestos para que sean exactamente enteros, utilice la función.round

    x(intcon) = round(x(intcon));

    Precaución

    Las soluciones de redondeo pueden hacer que la solución sea inviable. Compruebe la viabilidad después del redondeo:

    max(A*x - b) % See if entries are not too positive, so have small infeasibility max(abs(Aeq*x - beq)) % See if entries are near enough to zero max(x - ub) % Positive entries are violated bounds max(lb - x) % Positive entries are violated bounds
  • no exige que los componentes de la solución tengan un valor entero cuando superen sus valores absolutos.intlinprog2.1e9 Cuando la solución tiene estos componentes, le advierte.intlinprog Si recibe esta advertencia, Compruebe la solución para ver si los componentes con valores enteros supuestamente de la solución están cerca de enteros.

  • no permite que los componentes del problema, como los coeficientes en, o, excedan en valor absoluto.intlinprogfAub1e25 Si intenta ejecutar con este tipo de problema, emite un error.intlinprogintlinprog

  • Actualmente, no se puede ejecutar en el.intlinprogAplicación de optimización

Sugerencias

  • Para especificar variables binarias, establezca las variables en números enteros y déles límites inferiores y límites superiores de.intcon01

  • Ahorre memoria especificando matrices de restricciones lineales dispersas y.AAeq Sin embargo, no puede utilizar matrices dispersas para y.bbeq

  • Si incluye un argumento, utiliza ese valor en la heurística de buceo guiada hasta que encuentre un mejor punto de entero factible.x0intlinprog'rins' Así que cuando usted proporciona, usted puede obtener buenos resultados estableciendo la opción a u otra configuración que utiliza.x0'Heuristics''rins-diving''rins'

  • Para proporcionar índices lógicos para componentes enteros, es decir, un vector binario que indica un entero, conviértalo en formulario mediante.1intconfind Por ejemplo,

    logicalindices = [1,0,0,1,1,0,0]; intcon = find(logicalindices)
    intcon =       1     4     5
  • Reemplaza.intlinprogbintprog Para actualizar el código antiguo que se usará, realice los siguientes cambios:bintprogintlinprog

    • Establecer en, donde es el número de variables en su problema.intcon1:numVarsnumVars

    • Establecido en.lbzeros(numVars,1)

    • Establecido en.ubones(numVars,1)

    • Actualice las opciones relevantes. Se usa para crear opciones para.optimoptionsintlinprog

    • Cambia tu llamada de la siguiente manera:bintprog

      [x,fval,exitflag,output] = bintprog(f,A,b,Aeq,Beq,x0,options) % Change your call to: [x,fval,exitflag,output] = intlinprog(f,intcon,A,b,Aeq,Beq,lb,ub,x0,options)

Consideraciones de compatibilidad

expandir todo

El comportamiento cambió en R2019a

Introducido en R2014a