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.

solve

Resuelve el problema de optimización

Descripción

ejemplo

sol = solve(prob) resuelve el problema de optimización.prob

ejemplo

sol = solve(prob,x0) resuelve a partir del punto.probx0

ejemplo

sol = solve(___,Name,Value) modifica el proceso de solución mediante uno o varios argumentos de par nombre-valor además de los argumentos de entrada en sintaxis anteriores.

[sol,fval] = solve(___) también devuelve el valor de la función objetiva en la solución utilizando cualquiera de los argumentos de entrada en sintaxis anteriores.

ejemplo

[sol,fval,exitflag,output,lambda] = solve(___) también devuelve una marca de salida que describe la condición de salida, una estructura que contiene información adicional sobre el proceso de solución y, para problemas no enteros, una estructura de multiplicador de Lagrange.output

Ejemplos

contraer todo

Resuelva un problema de programación lineal definido por un problema de optimización.

 x = optimvar('x'); y = optimvar('y'); prob = optimproblem; prob.Objective = -x - y/3; prob.Constraints.cons1 = x + y <= 2; prob.Constraints.cons2 = x + y/4 <= 1; prob.Constraints.cons3 = x - y <= 2; prob.Constraints.cons4 = x/4 + y >= -1; prob.Constraints.cons5 = x + y >= 1; prob.Constraints.cons6 = -x + y <= 2;  sol = solve(prob)
Optimal solution found. 
sol = struct with fields:
    x: 0.6667
    y: 1.3333

Encuentre un mínimo de la función, que se incluye en MATLAB®, en la regiónpeaks

<math display="block">
<mrow>
<msup>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msup>
<mo>+</mo>
<msup>
<mrow>
<mi>y</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msup>
<mo></mo>
<mn>4</mn>
</mrow>
</math>
. Para ello, convierta la función en una expresión de optimización.peaks

prob = optimproblem; x = optimvar('x'); y = optimvar('y'); fun = fcn2optimexpr(@peaks,x,y); prob.Objective = fun;

Incluya la restricción como una desigualdad en las variables de optimización.

prob.Constraints = x^2 + y^2 <= 4;

Fije el punto inicial para 1 y a – 1, y resuelva el problema.xy

x0.x = 1; x0.y = -1; sol = solve(prob,x0)
Local minimum found that satisfies the constraints.  Optimization completed because the objective function is non-decreasing in  feasible directions, to within the value of the optimality tolerance, and constraints are satisfied to within the value of the constraint tolerance. 
sol = struct with fields:
    x: 0.2283
    y: -1.6255

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 enteras y cuatro restricciones de igualdad lineales, y todas las variables están restringidas para ser positivas.

prob = optimproblem; x = optimvar('x',8,1,'LowerBound',0,'Type','integer');

Cree cuatro restricciones de igualdad lineales e incluirlos en el problema.

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]; cons = Aeq*x == beq; prob.Constraints.cons = cons;

Crear una función objetiva e incluirlo en el problema.

f = [2    10    13    17     7     5     7     3]; prob.Objective = f*x;

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] = solve(prob);
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.21         0              -              -                                              18188      1.95         1   2.906000e+03   4.509804e+01                                              22039      2.43         2   2.073000e+03   2.270974e+01                                              24105      2.64         3   1.854000e+03   9.973046e+00                                              24531      2.69         3   1.854000e+03   1.347709e+00                                              24701      2.71         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.x = [8 62 23 103 53 84 46 34]'; [x2,fval2,exitflag2,output2] = solve(prob,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      0.95         3   1.854000e+03   1.180593e+01                                               6204      0.98         3   1.854000e+03   1.455526e+00                                               6400      1.00         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). 
fprintf('Without an initial point, solve took %d steps.\nWith an initial point, solve took %d steps.',output1.numnodes,output2.numnodes)
Without an initial point, solve took 24701 steps. With an initial point, solve took 6400 steps. 

Dar un punto inicial no siempre mejora el problema. Para este problema, el uso de un punto inicial ahorra tiempo y pasos computacionales. Sin embargo, para algunos problemas, un punto inicial puede hacer que se tomen más medidas.solve

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>
<mspace width="0.2777777777777778em"></mspace>
<mrow>
<mstyle mathvariant="normal">
<mrow>
<mrow>
<mi>s</mi>
<mi>u</mi>
<mi>b</mi>
<mi>j</mi>
<mi>e</mi>
<mi>c</mi>
<mi>t</mi>
</mrow>
</mrow>
</mstyle>
</mrow>
<mspace width="0.2777777777777778em"></mspace>
<mrow>
<mstyle mathvariant="normal">
<mrow>
<mrow>
<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>
<mspace width="0.2777777777777778em"></mspace>
<mrow>
<mstyle mathvariant="normal">
<mrow>
<mrow>
<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.

x = optimvar('x',2,1,'LowerBound',0); x3 = optimvar('x3','Type','integer','LowerBound',0,'UpperBound',1); prob = optimproblem; prob.Objective = -3*x(1) - 2*x(2) - x3; prob.Constraints.cons1 = x(1) + x(2) + x3 <= 7; prob.Constraints.cons2 = 4*x(1) + 2*x(2) + x3 == 12;  options = optimoptions('intlinprog','Display','off');  sol = solve(prob,'Options',options)
sol = struct with fields:
     x: [2x1 double]
    x3: 1

Examine la solución.

sol.x
ans = 2×1

         0
    5.5000

sol.x3
ans = 1 

Forzar el uso como solucionador de un problema de programación lineal.solveintlinprog

x = optimvar('x'); y = optimvar('y'); prob = optimproblem; prob.Objective = -x - y/3; prob.Constraints.cons1 = x + y <= 2; prob.Constraints.cons2 = x + y/4 <= 1; prob.Constraints.cons3 = x - y <= 2; prob.Constraints.cons4 = x/4 + y >= -1; prob.Constraints.cons5 = x + y >= 1; prob.Constraints.cons6 = -x + y <= 2;  sol = solve(prob,'Solver', 'intlinprog')
LP:                Optimal objective value is -1.111111.                                               Optimal solution found.  No integer variables specified. Intlinprog solved the linear problem. 
sol = struct with fields:
    x: 0.6667
    y: 1.3333

Resuelva el problema de programación lineal de enteros mixtos descrito en y examine todos los datos de salida.Resolver problema de programación de enteros con opciones no predeterminadas

x = optimvar('x',2,1,'LowerBound',0); x3 = optimvar('x3','Type','integer','LowerBound',0,'UpperBound',1); prob = optimproblem; prob.Objective = -3*x(1) - 2*x(2) - x3; prob.Constraints.cons1 = x(1) + x(2) + x3 <= 7; prob.Constraints.cons2 = 4*x(1) + 2*x(2) + x3 == 12;  [sol,fval,exitflag,output] = solve(prob)
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 = struct with fields:
     x: [2x1 double]
    x3: 1

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

Para un problema sin restricciones de enteros, también puede obtener una estructura de multiplicador de Lagrange no vacía como la quinta salida.

Crear y resolver un problema de optimización mediante variables de índice con nombre. El problema consiste en maximizar el flujo de fruta ponderado con beneficios a varios aeropuertos, sujeto a restricciones en los flujos ponderados.

rng(0) % For reproducibility p = optimproblem('ObjectiveSense', 'maximize'); flow = optimvar('flow', ...     {'apples', 'oranges', 'bananas', 'berries'}, {'NYC', 'BOS', 'LAX'}, ...     'LowerBound',0,'Type','integer'); p.Objective = sum(sum(rand(4,3).*flow)); p.Constraints.NYC = rand(1,4)*flow(:,'NYC') <= 10; p.Constraints.BOS = rand(1,4)*flow(:,'BOS') <= 12; p.Constraints.LAX = rand(1,4)*flow(:,'LAX') <= 35; sol = solve(p);
LP:                Optimal objective value is -1027.472366.                                           Heuristics:        Found 1 solution using rounding.                                                                     Upper bound is -1027.233133.                                                                         Relative gap is 0.00%.                                                            Cut Generation:    Applied 1 mir cut, and 2 strong CG cuts.                                                             Lower bound is -1027.233133.                                                                         Relative gap is 0.00%.                                                             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). 

Encuentre el flujo óptimo de naranjas y bayas a Nueva York y los Ángeles.

[idxFruit,idxAirports] = findindex(flow, {'oranges','berries'}, {'NYC', 'LAX'})
idxFruit = 1×2

     2     4

idxAirports = 1×2

     1     3

orangeBerries = sol.flow(idxFruit, idxAirports)
orangeBerries = 2×2

         0  980.0000
   70.0000         0

Esta pantalla significa que ninguna naranja va a, 70 bayas van a, 980 naranjas van a, y no hay bayas van a.NYCNYCLAXLAX

Enumere el flujo óptimo de lo siguiente:

Fruit Airports

----- --------

Berries NYC

Apples BOS

Oranges LAX

idx = findindex(flow, {'berries', 'apples', 'oranges'}, {'NYC', 'BOS', 'LAX'})
idx = 1×3

     4     5    10

optimalFlow = sol.flow(idx)
optimalFlow = 1×3

   70.0000   28.0000  980.0000

Esta pantalla significa que 70 bayas van a, 28 manzanas van a, y 980 naranjas van a.NYCBOSLAX

Argumentos de entrada

contraer todo

Problema de optimización, especificado como un objeto.OptimizationProblem Crear un problema mediante el uso de.optimproblem

Ejemplo: prob = optimproblem; prob.Objective = obj; prob.Constraints.cons1 = cons1;

Punto inicial, especificado como una estructura con nombres de campo iguales a los nombres de variable en.prob

Para obtener un ejemplo con las variables de índice con nombre, vea.x0Cree un punto inicial para la optimización con variables de índice guardadas

Ejemplo: Si tiene variables nombradas y:.probxyx0.x = [3,2,17]; x0.y = [pi/3,2*pi/3]

Tipos de datos: struct

Argumentos de par nombre-valor

Especifique pares de argumentos separados por comas opcionales. es el nombre del argumento y es el valor correspondiente. deben aparecer dentro de las cotizaciones.Name,ValueNameValueName Puede especificar varios argumentos de par de nombre y valor en cualquier orden como.Name1,Value1,...,NameN,ValueN

Ejemplo: solve(prob,'options',opts)

Opciones de optimización, especificadas como el par separado por comas que consta de un objeto creado por o una estructura de opciones como creado por.'options'optimoptionsoptimset

Internamente, la función llama,,,,,, o.solvelinprogintlinprogquadproglsqlinlsqnonnegfminuncfmincon Para el solucionador predeterminado, consulte.'solver'

Asegúrese de que son compatibles con el solucionador.Opciones Por ejemplo, no permite que las opciones sean una estructura y no permite que las opciones sean un objeto.intlinproglsqnonneg

Para obtener sugerencias sobre la configuración de opciones para mejorar una solución o la velocidad de una solución, consulte.intlinprogAjuste de programación lineal de enteros Para, el algoritmo predeterminado es generalmente eficiente en memoria y rápido.linprog'dual-simplex' Ocasionalmente, resuelve un gran problema más rápido cuando la opción es.linprogAlgorithm'interior-point' Para obtener sugerencias sobre la configuración de opciones para mejorar la solución de un problema no lineal, consulte y.Opciones de uso común: sintonización y solución de problemasMejore los resultados

Ejemplo: options = optimoptions('intlinprog','Display','none')

Solucionador de optimización, especificado como el par separado por comas que consta y el nombre de un solucionador enumerado.'solver'

Tipo de problemaSolver predeterminadoOtros Solvers permitidos
Objetivos lineales, restricciones linealeslinprog,intlinprogquadprog
Las restricciones lineales objetivas, lineales y de enterosintlinprog, (se omiten las restricciones de enteros)linprogquadprog
Objetivo cuadrático, restricciones linealesquadprog, (si el objetivo no se puede convertir para minimizar | | C * x-d | | ^ 2 entonces arroja un error para estos solucionadores)lsqlinlsqnonnegsolve
Minimizar | | C * x-d | | ^ 2 sujeto a restricciones linealesCuando el objetivo es una constante más una suma de cuadrados de expresiones linealeslsqlin, (Se omiten las restricciones que no sean x > = 0)quadproglsqnonneglsqnonneg
Minimizar | | C * x-d | | ^ 2 sujeto a x > = 0lsqlin,quadproglsqnonneg
Minimizar la función no lineal general ()fxfminuncfmincon
Minimice la función no lineal general () sujeta a algunas restricciones o minimice cualquier función sujeta a restricciones no linealesfxfminconninguno

Precaución

Para los problemas de maximización, no especifique los y solucionadores.lsqlinlsqnonneg Si lo hace, produce un error, porque estos solucionadores no pueden maximizar.solve

Ejemplo: 'intlinprog'

Tipos de datos: char | string

Argumentos de salida

contraer todo

Solución, devuelta como una estructura. Los campos de la estructura son los nombres de las variables de optimización. Ver.optimvar

Valor de la función objetiva en la solución, devuelto como un número real.

Sugerencia

Si descuidas pedir, puedes calcularlo usando:fval

fval = evaluate(prob.Objective,sol)

Motivo por el que el solucionador se detuvo, devuelto como variable categórica. En esta tabla se describen las marcas de salida del solucionador.intlinprog

Marca de salida paraintlinprogEquivalente numéricoSignificado
OptimalWithPoorFeasibility3

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

IntegerFeasible2detenido prematuramente y encontró un punto entero factible.intlinprog
OptimalSolution

1

El solucionador convergió en una solución.x

SolverLimitExceeded

0

supere una de las siguientes tolerancias:intlinprog

  • LPMaxIterations

  • MaxNodes

  • MaxTime

  • RootLPMaxIterations

Ver. también devuelve esta marca de salida cuando se ejecuta fuera de la memoria en el nodo raíz.Tolerancias y criterios de detenciónsolve

OutputFcnStop-1detenido por una función de salida o una función de trazado.intlinprog
NoFeasiblePointFound

-2

No se encontró un punto factible.

Unbounded

-3

El problema es ilimitado.

FeasibilityLost

-9

Solver perdió viabilidad.

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.

En esta tabla se describen las marcas de salida del solucionador.linprog

Marca de salida paralinprogEquivalente numéricoSignificado
OptimalWithPoorFeasibility3

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

OptimalSolution1

El solucionador convergió en una solución.x

SolverLimitExceeded0

El número de iteraciones supera.options.MaxIterations

NoFeasiblePointFound-2

No se encontró un punto factible.

Unbounded-3

El problema es ilimitado.

FoundNaN-4

valor encontrado durante la ejecución del algoritmo.NaN

PrimalDualInfeasible-5

Tanto los problemas primarios como los duales son inviables.

DirectionTooSmall-7

La dirección de búsqueda es demasiado pequeña. No se pueden hacer más progresos.

FeasibilityLost-9

Solver perdió viabilidad.

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.

En esta tabla se describen las marcas de salida del solucionador.lsqlin

Marca de salida paralsqlinEquivalente numéricoSignificado
FunctionChangeBelowTolerance3

El cambio en el residuo es menor que la tolerancia especificada. algoritmooptions.FunctionTolerancetrust-region-reflective

StepSizeBelowTolerance

2

Tamaño de paso menor que, restricciones satisfechas. algoritmooptions.StepToleranceinterior-point

OptimalSolution1

El solucionador convergió en una solución.x

SolverLimitExceeded0

El número de iteraciones supera.options.MaxIterations

NoFeasiblePointFound-2

El problema es inviable. O, para el algoritmo, el tamaño del paso es menor que, pero las restricciones no se satisfacen.interior-pointoptions.StepTolerance

IllConditioned-4

El mal acondicionamiento evita una mayor optimización.

NoDescentDirectionFound-8

La dirección de búsqueda es demasiado pequeña. No se pueden hacer más progresos. algoritmointerior-point

En esta tabla se describen las marcas de salida del solucionador.quadprog

Marca de salida paraquadprogEquivalente numéricoSignificado
LocalMinimumFound4

Mínimo local encontrado; mínimo no es único.

FunctionChangeBelowTolerance3

El cambio en el valor de la función objetiva es menor que la tolerancia especificada. algoritmooptions.FunctionTolerancetrust-region-reflective

StepSizeBelowTolerance

2

Tamaño de paso menor que, restricciones satisfechas. algoritmooptions.StepToleranceinterior-point-convex

OptimalSolution1

El solucionador convergió en una solución.x

SolverLimitExceeded0

El número de iteraciones supera.options.MaxIterations

NoFeasiblePointFound-2

El problema es inviable. O, para el algoritmo, el tamaño del paso es menor que, pero las restricciones no se satisfacen.interior-pointoptions.StepTolerance

IllConditioned-4

El mal acondicionamiento evita una mayor optimización.

Nonconvex

-6

Problema no convexo detectado. algoritmointerior-point-convex

NoDescentDirectionFound-8

No se puede calcular una dirección de paso. algoritmointerior-point-convex

En esta tabla se describen las marcas de salida del solucionador.fminunc

Marca de salida parafminuncEquivalente numéricoSignificado
NoDecreaseAlongSearchDirection5

La disminución pronosticada en la función objetiva es menor que la tolerancia.options.FunctionTolerance

FunctionChangeBelowTolerance3

El cambio en el valor de la función objetiva es menor que la tolerancia.options.FunctionTolerance

StepSizeBelowTolerance

2

El cambio es menor que la tolerancia.xoptions.StepTolerance

OptimalSolution1

La magnitud del degradado es menor que la tolerancia.options.OptimalityTolerance

SolverLimitExceeded0

El número de iteraciones excede o el número de evaluaciones de función excede.options.MaxIterationsoptions.MaxFunctionEvaluations

OutputFcnStop-1

Detenido por una función de salida o una función de trazado.

Unbounded-3

La función objetiva en la iteración actual está por debajo.options.ObjectiveLimit

En esta tabla se describen las marcas de salida del solucionador.fmincon

Marca de salida parafminconEquivalente numéricoSignificado
NoDecreaseAlongSearchDirection5

La magnitud del derivado direccional en la dirección de búsqueda es menor que 2 * y la infracción de restricción máxima es menor que.options.OptimalityToleranceoptions.ConstraintTolerance

SearchDirectionTooSmall4

La magnitud de la dirección de búsqueda es menor que 2 * y la infracción de restricción máxima es menor que.options.StepToleranceoptions.ConstraintTolerance

FunctionChangeBelowTolerance3

El cambio en el valor de la función objetiva es menor que y la infracción de restricción máxima es menor que.options.FunctionToleranceoptions.ConstraintTolerance

StepSizeBelowTolerance

2

El cambio en es menor que y la infracción de restricción máxima es menor que.xoptions.StepToleranceoptions.ConstraintTolerance

OptimalSolution1

La medida de optimalidad de primer orden es menor que, y la infracción de restricción máxima es menor que.options.OptimalityToleranceoptions.ConstraintTolerance

SolverLimitExceeded0

El número de iteraciones excede o el número de evaluaciones de función excede.options.MaxIterationsoptions.MaxFunctionEvaluations

OutputFcnStop-1

Detenido por una función de salida o una función de trazado.

NoFeasiblePointFound-2

No se encontró un punto factible.

Unbounded-3

La función objetiva en la iteración actual está por debajo y la infracción de restricción máxima es menor que.options.ObjectiveLimitoptions.ConstraintTolerance

Información sobre el proceso de optimización, devuelta como una estructura. La estructura de salida contiene los campos del campo de salida del solucionador subyacente relevante, en función del solucionador llamado:solve

incluye el campo adicional en la estructura para identificar el solucionador utilizado, como.solveSolveroutput'intlinprog'

Los multiplicadores de Lagrange en la solución, regresaron como una estructura. Para el solucionador, está vacío,.intlinproglambda[] Para los otros solucionadores, tiene estos campos:lambda

  • : Contiene campos para cada variable problemática.Variables Cada nombre de variable de problema es una estructura con dos campos:

    • – Multiplicadores de Lagrange asociados a la propiedad variable, devueltos como una matriz del mismo tamaño que la variable.LowerLowerBound Las entradas de distinto cero significan que la solución está en el límite inferior. Estos multiplicadores están en la estructura lambda.Variables.variablename.Lower.

    • – Multiplicadores de Lagrange asociados a la propiedad variable, devueltos como una matriz del mismo tamaño que la variable.UpperUpperBound Las entradas de distinto cero significan que la solución está en el límite superior. Estos multiplicadores están en la estructura lambda.Variables.variablename.Upper.

  • : Contiene un campo para cada restricción de problemas.Restricciones Cada restricción de problemas está en una estructura cuyo nombre es el nombre de la restricción y cuyo valor es una matriz numérica del mismo tamaño que la restricción. Las entradas de distinto cero significan que la restricción está activa en la solución. Estos multiplicadores están en la estructura lambda.Constraints.constraintname.

    Nota

    Todos los elementos de una matriz de restricciones tienen la misma comparación (, o) y son todos del mismo tipo (lineales, cuadráticos o no lineales).<===>=

Algoritmos

Internamente, la función resuelve problemas de optimización llamando a un solucionador:solve

  • para las restricciones lineales objetivas y linealeslinprog

  • para las restricciones lineales objetivas y lineales y las restricciones de enterosintlinprog

  • para las restricciones lineales y objetivas cuadráticasquadprog

  • o para mínimos cuadrados lineales con restricciones linealeslsqlinlsqnonneg

  • para problemas sin restricciones (ni siquiera límites variables) y con una función de objetivo no lineal generalfminunc

  • para problemas con una restricción no lineal, o con un objetivo general no lineal y al menos una restricciónfmincon

Antes puede llamar a estas funciones, los problemas se deben convertir al formulario del solucionador, ya sea por o algunas otras funciones o objetos asociados.solvesolve Esta conversión implica, por ejemplo, las restricciones lineales que tienen una representación de matriz en lugar de una expresión de variable de optimización.

El primer paso del algoritmo se produce cuando se colocan expresiones de optimización en el problema. Un objeto tiene una lista interna de las variables utilizadas en sus expresiones.OptimizationProblem Cada variable tiene un índice lineal en la expresión y un tamaño. Por lo tanto, las variables de problema tienen una forma de matriz implícita. La función realiza la conversión del formulario de problema al formulario de solucionador.prob2struct Para ver un ejemplo, vea.Convertir problema a estructura

Para los solucionadores predeterminados y permitidos que llama, según el objetivo del problema y las restricciones, consulte.solve'solver' Puede invalidar el valor predeterminado mediante el argumento de par nombre-valor al llamar.'solver'solve

Para el algoritmo que utiliza para resolver problemas MILP, vea.intlinprogAlgoritmo intlinprog Para los algoritmos que se utilizan para resolver problemas de programación lineal, consulte.linprogAlgoritmos de programación lineal Para los algoritmos que se utilizan para resolver problemas de programación cuadrática, vea.quadprogAlgoritmos de programación cuadrática Para los algoritmos que se utilizan para resolver problemas lineales de mínimos cuadrados, consulte.lsqlinAlgoritmos de mínimos cuadrados (ajuste de modelo) Para los algoritmos de solucionador no lineales, vea y.Algoritmos de optimización no lineales no restringidosAlgoritmos de optimización no lineales restringidos

Nota

Si su función objetiva es una suma de cuadrados, y desea reconocerla como tal, escríbelo como, y no como.solvesum(expr.^2)expr'*expr El analizador interno reconoce sólo las sumas explícitas de los cuadrados. Para ver un ejemplo, vea.Mínimos cuadrados no negativos, basados en problemas

Consideraciones de compatibilidad

expandir todo

Errores a partir de R2018b

Introducido en R2017b