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.

lsqlin

Resolver problemas de mínimos cuadrados lineales restringidos

Sintaxis

x = lsqlin(C,d,A,b)

x = lsqlin(C,d,A,b,Aeq,beq,lb,ub)

x = lsqlin(C,d,A,b,Aeq,beq,lb,ub,x0,options)

x = lsqlin(problem)

[x,resnorm,residual,exitflag,output,lambda] = lsqlin(___)

[wsout,resnorm,residual,exitflag,output,lambda] = lsqlin(C,d,A,b,Aeq,beq,lb,ub,ws)

Descripción

Solver de mínimos cuadrados lineales con límites o restricciones lineales.

Resuelve problemas de ajuste de curvas de mínimos cuadrados con el formato

$$\underset{x}{\min }\frac{1}{2}{\Vert C\cdot x-d\Vert }_2^2\text{ such that }\{\begin{array}{c}A\cdot x\le b,\\ Aeq\cdot x=beq,\\ lb\le x\le ub.\end{array}$$

Nota

lsqlin se aplica únicamente al enfoque basado en solvers. Para ver una exposición sobre los dos enfoques de optimización, consulte En primer lugar, elija el enfoque basado en problemas o el enfoque basado en solvers.

x = lsqlin(C,d,A,b) resuelve el sistema lineal C*x = d en el sentido de mínimos cuadrados, sujeto a A*x ≤ b.

x = lsqlin(C,d,A,b,Aeq,beq,lb,ub) agrega restricciones de igualdad lineales Aeq*x = beq y límites lb ≤ x ≤ ub. Si no necesita determinadas restricciones, como Aeq y beq, establézcalas en []. Si x(i) está desacotado por abajo, establezca lb(i) = -Inf, y si x(i) está desacotado por arriba, establezca ub(i) = Inf.

x = lsqlin(C,d,A,b,Aeq,beq,lb,ub,x0,options) minimiza con un punto inicial x0 y las opciones de optimización especificadas en options. Utilice optimoptions para configurar estas opciones. Si no desea incluir un punto inicial, establezca el argumento x0 en []; no obstante, se requiere un x0 no vacío para el algoritmo 'active-set'.

x = lsqlin(problem) encuentra el mínimo para problem, una estructura descrita en problem. Cree la estructura problem utilizando notación de puntos o la función struct. O cree una estructura problem a partir de un objeto OptimizationProblem utilizando prob2struct.

[x,resnorm,residual,exitflag,output,lambda] = lsqlin(___), para cualquiera de los argumentos de entrada que se describen arriba, devuelve:

• La norma euclídea al cuadrado del valor residual resnorm = $${\Vert C\cdot x-d\Vert }_2^2$$

• El valor residual residual = C*x - d

• Un valor exitflag que describe la condición de salida

• Una estructura output que contiene información sobre el proceso de optimización

• Una estructura lambda que contiene los multiplicadores de Lagrange

  El factor ½ en la definición del problema afecta a los valores de la estructura lambda.

[wsout,resnorm,residual,exitflag,output,lambda] = lsqlin(C,d,A,b,Aeq,beq,lb,ub,ws) inicia lsqlin a partir de los datos del objeto ws de arranque en caliente, utilizando las opciones de ws. El argumento wsout devuelto contiene el punto de solución en wsout.X. Utilizando wsout como el objeto inicial de arranque en caliente en una llamada de solver posterior, lsqlin puede funcionar más rápidamente.

Ejemplos

Mínimos cuadrados con restricciones de desigualdad lineales

Encuentre la x que minimice la norma de C*x - d para un problema sobredeterminado con restricciones de desigualdad lineales.

Especifique el problema y las restricciones.

C = [0.9501    0.7620    0.6153    0.4057
    0.2311    0.4564    0.7919    0.9354
    0.6068    0.0185    0.9218    0.9169
    0.4859    0.8214    0.7382    0.4102
    0.8912    0.4447    0.1762    0.8936];
d = [0.0578
    0.3528
    0.8131
    0.0098
    0.1388];
A = [0.2027    0.2721    0.7467    0.4659
    0.1987    0.1988    0.4450    0.4186
    0.6037    0.0152    0.9318    0.8462];
b = [0.5251
    0.2026
    0.6721];

Llame a lsqlin para resolver el problema.

x = lsqlin(C,d,A,b)

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.

x = 4×1

    0.1299
   -0.5757
    0.4251
    0.2438

Mínimos cuadrados con restricciones lineales y límites

Encuentre la x que minimice la norma de C*x - d para un problema sobredeterminado con restricciones de desigualdad e igualdad lineales y límites.

Especifique el problema y las restricciones.

C = [0.9501    0.7620    0.6153    0.4057
    0.2311    0.4564    0.7919    0.9354
    0.6068    0.0185    0.9218    0.9169
    0.4859    0.8214    0.7382    0.4102
    0.8912    0.4447    0.1762    0.8936];
d = [0.0578
    0.3528
    0.8131
    0.0098
    0.1388];
A =[0.2027    0.2721    0.7467    0.4659
    0.1987    0.1988    0.4450    0.4186
    0.6037    0.0152    0.9318    0.8462];
b =[0.5251
    0.2026
    0.6721];
Aeq = [3 5 7 9];
beq = 4;
lb = -0.1*ones(4,1);
ub = 2*ones(4,1);

Llame a lsqlin para resolver el problema.

x = lsqlin(C,d,A,b,Aeq,beq,lb,ub)

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.

x = 4×1

   -0.1000
   -0.1000
    0.1599
    0.4090

Mínimos cuadrados lineales con opciones no predeterminadas

Este ejemplo muestra cómo usar opciones no predeterminadas para mínimos cuadrados lineales.

Establezca opciones para utilizar el algoritmo 'interior-point' y para proporcionar la visualización iterativa.

options = optimoptions('lsqlin','Algorithm','interior-point','Display','iter');

Configure un problema de mínimos cuadrados lineales.

C = [0.9501    0.7620    0.6153    0.4057
    0.2311    0.4564    0.7919    0.9354
    0.6068    0.0185    0.9218    0.9169
    0.4859    0.8214    0.7382    0.4102
    0.8912    0.4447    0.1762    0.8936];
d = [0.0578
    0.3528
    0.8131
    0.0098
    0.1388];
A = [0.2027    0.2721    0.7467    0.4659
    0.1987    0.1988    0.4450    0.4186
    0.6037    0.0152    0.9318    0.8462];
b = [0.5251
    0.2026
    0.6721];

Ejecute el problema.

x = lsqlin(C,d,A,b,[],[],[],[],[],options)

 Iter         Resnorm  Primal Infeas    Dual Infeas  Complementarity  
    0    6.545534e-01   1.600492e+00   6.150431e-01     1.000000e+00  
    1    6.545534e-01   8.002458e-04   3.075216e-04     2.430833e-01  
    2    1.757343e-01   4.001229e-07   1.537608e-07     5.945636e-02  
    3    5.619277e-02   2.000615e-10   2.036997e-08     1.370933e-02  
    4    2.587604e-02   9.994783e-14   1.006816e-08     2.548273e-03  
    5    1.868939e-02   2.775558e-17   2.955102e-09     4.295807e-04  
    6    1.764630e-02   2.775558e-17   1.237758e-09     3.102850e-05  
    7    1.758561e-02   2.498002e-16   1.645864e-10     1.138719e-07  
    8    1.758538e-02   2.498002e-16   2.399331e-13     5.693290e-11  

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.

x = 4×1

    0.1299
   -0.5757
    0.4251
    0.2438

Devolver todas las salidas

Obtenga e interprete todas las salidas de lsqlin.

Defina un problema con restricciones de desigualdad lineales y límites. El problema está sobredeterminado dado que hay cuatro columnas en la matriz C, pero cinco filas. Esto significa que el problema tiene cuatro incógnitas y cinco condiciones, incluso antes de incluir las restricciones lineales y los límites.

C = [0.9501    0.7620    0.6153    0.4057
    0.2311    0.4564    0.7919    0.9354
    0.6068    0.0185    0.9218    0.9169
    0.4859    0.8214    0.7382    0.4102
    0.8912    0.4447    0.1762    0.8936];
d = [0.0578
    0.3528
    0.8131
    0.0098
    0.1388];
A = [0.2027    0.2721    0.7467    0.4659
    0.1987    0.1988    0.4450    0.4186
    0.6037    0.0152    0.9318    0.8462];
b = [0.5251
    0.2026
    0.6721];
lb = -0.1*ones(4,1);
ub = 2*ones(4,1);

Establezca opciones para utilizar el algoritmo 'interior-point'.

options = optimoptions('lsqlin','Algorithm','interior-point');

El algoritmo 'interior-point' no usa un punto inicial, por lo que establezca x0 en [].

x0 = [];

Llame a lsqlin con todas las salidas.

[x,resnorm,residual,exitflag,output,lambda] = ...
    lsqlin(C,d,A,b,[],[],lb,ub,x0,options)

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.

x = 4×1

   -0.1000
   -0.1000
    0.2152
    0.3502

resnorm = 0.1672

residual = 5×1

    0.0455
    0.0764
   -0.3562
    0.1620
    0.0784

exitflag = 1

output = struct with fields:
            message: 'Minimum found that satisfies the constraints....'
          algorithm: 'interior-point'
      firstorderopt: 4.3374e-11
    constrviolation: 0
         iterations: 6
       linearsolver: 'dense'
       cgiterations: []

lambda = struct with fields:
    ineqlin: [3x1 double]
      eqlin: [0x1 double]
      lower: [4x1 double]
      upper: [4x1 double]

Examine los campos del multiplicador de Lagrange distintos de cero más detalladamente. En primer lugar, examine los multiplicadores de Lagrange para la restricción de desigualdad lineal.

lambda.ineqlin

ans = 3×1

    0.0000
    0.2392
    0.0000

Los multiplicadores de Lagrange son distintos de cero exactamente cuando la solución está en el límite de la restricción correspondiente. En otras palabras, los multiplicadores de Lagrange son distintos de cero cuando la restricción correspondiente está activa. lambda.ineqlin(2) es distinta de cero. Esto significa que el segundo elemento de A*x debería ser igual al segundo elemento de b, dado que la restricción está activa.

[A(2,:)*x,b(2)]

ans = 1×2

    0.2026    0.2026

Ahora, examine los multiplicadores de Lagrange para las restricciones del límite inferior y superior.

lambda.lower

ans = 4×1

    0.0409
    0.2784
    0.0000
    0.0000

lambda.upper

ans = 4×1

     0
     0
     0
     0

Los dos primeros elementos de lambda.lower son distintos de cero. Observe que x(1) y x(2) son sus límites inferiores, -0.1. Todos los elementos de lambda.upper son esencialmente cero y puede ver que todos los componentes de x son inferiores a su límite superior, 2.

Devolver un objeto de arranque en caliente

Cree un objeto de arranque en caliente de manera que pueda resolver rápidamente un problema modificado. Establezca opciones para desactivar la visualización iterativa para admitir un arranque en caliente.

rng default % For reproducibility
options = optimoptions('lsqlin','Algorithm','active-set','Display','off');
n = 15;
x0 = 5*rand(n,1);
ws = optimwarmstart(x0,options);

Cree y resuelva el primer problema. Encuentre el tiempo de resolución.

r = 1:n-1; % Index for making vectors
v(n) = (-1)^(n+1)/n; % Allocating the vector v
v(r) =( -1).^(r+1)./r;
C = gallery('circul',v);
C = [C;C];
r = 1:2*n;
d(r) = n-r;
lb = -5*ones(1,n);
ub = 5*ones(1,n);
tic
[ws,fval,~,exitflag,output] = lsqlin(C,d,[],[],[],[],lb,ub,ws)
toc

Elapsed time is 0.005117 seconds.

Agregue una restricción lineal y resuélvalo de nuevo.

A = ones(1,n);
b = -10;
tic
[ws,fval,~,exitflag,output] = lsqlin(C,d,A,b,[],[],lb,ub,ws)
toc

Elapsed time is 0.001491 seconds.

Argumentos de entrada

C — Matriz multiplicadora

matriz real

La matriz multiplicadora, especificada como una matriz de dobles. C representa el multiplicador de la solución x en la expresión C*x - d. C es M por N, donde M es el número de ecuaciones y N es el número de elementos de x.

Ejemplo: C = [1,4;2,5;7,8]

Tipos de datos: double

d — Vector de constantes

vector real

La matriz multiplicadora, especificada como un vector de dobles. d representa el término constante aditivo en la expresión C*x - d. d es M por 1, donde M es el número de ecuaciones.

Ejemplo: d = [5;0;-12]

Tipos de datos: double

A — Restricciones de desigualdad lineales

matriz real

Restricciones de desigualdad lineales, especificadas como una matriz real. A es una matriz de M por N, donde M es el número de desigualdades y N es el número de variables (número de elementos de x0). Para problemas grandes, pase A como una matriz dispersa.

A codifica las M desigualdades lineales

A*x <= b,

donde x es el vector columna de N variables x(:) y b es un vector columna con M elementos.

Por ejemplo, considere estas desigualdades:

x₁ + 2x₂ ≤ 10
3x₁ + 4x₂ ≤ 20
5x₁ + 6x₂ ≤ 30,

Especifique las desigualdades introduciendo las siguientes restricciones.

A = [1,2;3,4;5,6];
b = [10;20;30];

Ejemplo: Para especificar que los componentes de x suman 1 o menos, utilice A = ones(1,N) y b = 1.

Tipos de datos: double

b — Restricciones de desigualdad lineales

vector real

Restricciones de desigualdad lineales, especificadas como un vector real. b es un vector de M elementos relacionado con la matriz A. Si pasa b como un vector fila, los solvers convierten internamente b en el vector columna b(:). Para problemas grandes, pase b como un vector disperso.

b codifica las M desigualdades lineales

A*x <= b,

donde x es el vector columna de N variables x(:) y A es una matriz de tamaño M por N.

Por ejemplo, considere estas desigualdades:

x₁ + 2x₂ ≤ 10
3x₁ + 4x₂ ≤ 20
5x₁ + 6x₂ ≤ 30.

Especifique las desigualdades introduciendo las siguientes restricciones.

A = [1,2;3,4;5,6];
b = [10;20;30];

Ejemplo: Para especificar que los componentes de x suman 1 o menos, utilice A = ones(1,N) y b = 1.

Tipos de datos: double

Aeq — Restricciones de igualdad lineales

matriz real

Restricciones de igualdad lineales, especificadas como una matriz real. Aeq es una matriz de Me por N, donde Me es el número de igualdades y N es el número de variables (número de elementos de x0). Para problemas grandes, pase Aeq como una matriz dispersa.

Aeq codifica las Me igualdades lineales

Aeq*x = beq,

donde x es el vector columna de N variables x(:) y beq es un vector columna con Me elementos.

Por ejemplo, considere estas desigualdades:

x₁ + 2x₂ + 3x₃ = 10
2x₁ + 4x₂ + x₃ = 20,

Especifique las desigualdades introduciendo las siguientes restricciones.

Aeq = [1,2,3;2,4,1];
beq = [10;20];

Ejemplo: Para especificar que los componentes de x suman 1, utilice Aeq = ones(1,N) y beq = 1.

Tipos de datos: double

beq — Restricciones de igualdad lineales

vector real

Restricciones de igualdad lineales, especificadas como un vector real. beq es un vector de Me elementos relacionado con la matriz Aeq. Si pasa beq como un vector fila, los solvers convierten internamente beq en el vector columna beq(:). Para problemas grandes, pase beq como un vector disperso.

beq codifica las Me igualdades lineales

Aeq*x = beq,

donde x es el vector columna de N variables x(:) y Aeq es una matriz de tamaño Me por N.

Por ejemplo, considere estas igualdades:

x₁ + 2x₂ + 3x₃ = 10
2x₁ + 4x₂ + x₃ = 20.

Especifique las igualdades introduciendo las siguientes restricciones.

Aeq = [1,2,3;2,4,1];
beq = [10;20];

Ejemplo: Para especificar que los componentes de x suman 1, utilice Aeq = ones(1,N) y beq = 1.

Tipos de datos: double

lb — Límites inferiores

[] (predeterminado) | vector o arreglo real

Límites inferiores, especificados como un vector o un arreglo de dobles. lb representa los límites inferiores por elementos en lb ≤ x ≤ ub.

Internamente, lsqlin convierte un arreglo lb en el vector lb(:).

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

Tipos de datos: double

ub — Límites superiores

[] (predeterminado) | vector o arreglo real

Límites superiores, especificados como un vector o un arreglo de dobles. ub representa los límites superiores por elementos en lb ≤ x ≤ ub.

Internamente, lsqlin convierte un arreglo ub en el vector ub(:).

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

Tipos de datos: double

x0 — Punto inicial

zeros(M,1) donde M es el número de ecuaciones (predeterminado) | vector o arreglo real

Punto inicial para el proceso de resolución, especificado como un vector o arreglo real.

• El algoritmo 'interior-point' no utiliza x0.

• x0 es un argumento opcional para el algoritmo 'trust-region-reflective'. De forma predeterminada, este algoritmo establece x0 en un vector de todo ceros. Si alguno de estos componentes vulnera los límites de restricción, lsqlin restablece el valor predeterminado x0 completo a un vector que cumpla los límites. Si alguno de los componentes de un valor x0 no predeterminado vulnera los límites, lsqlin establece esos componentes para que cumplan los límites.

• Un valor x0 no vacío es un argumento requerido para el algoritmo 'active-set'. Si alguno de los componentes de un valor x0 vulnera los límites, lsqlin establece esos componentes para que cumplan los límites.

Ejemplo: x0 = [4;-3]

Tipos de datos: double

options — Opciones para lsqlin

opciones creadas utilizando optimoptions | estructura como la creada por optimset

Opciones para lsqlin, especificadas como la salida de la función optimoptions o como una estructura como la creada por optimset.

Algunas opciones no aparecen en la visualización optimoptions. Estas opciones se muestran en cursiva en la siguiente tabla. Para obtener más detalles, consulte Consultar las opciones de optimización.

Todos los algoritmos

Algorithm	Escoja el algoritmo: 'interior-point' (valor predeterminado) 'trust-region-reflective' 'active-set' El algoritmo 'trust-region-reflective' solo admite límites superiores e inferiores, no desigualdades o igualdades lineales. Si especifica tanto el algoritmo 'trust-region-reflective' como las restricciones lineales, lsqlin usa el algoritmo 'interior-point'. El algoritmo 'trust-region-reflective' no permite límites superiores e inferiores iguales. Cuando el problema no tiene restricciones, lsqlin llama a mldivide internamente. Si tiene un número elevado de restricciones lineales y un número no elevado de variables, pruebe el algoritmo 'active-set'. Para obtener más información sobre cómo elegir el algoritmo, consulte Seleccionar el algoritmo.
Diagnóstico	Muestre información de diagnóstico sobre la función que se desea minimizar o resolver. Las opciones son 'on' o la opción predeterminada 'off'.
Display	Nivel de visualización devuelto a la línea de comandos. 'off' o 'none' no muestran salida alguna. 'final' solo muestra la salida final (valor predeterminado). Los algoritmos 'interior-point' y 'active-set' admiten valores adicionales: 'iter' proporciona la visualización iterativa. 'iter-detailed' proporciona la visualización iterativa con un mensaje de salida detallado. 'final-detailed' muestra solo la salida final con un mensaje de salida detallado.
MaxIterations	Número máximo de iteraciones permitidas, un entero positivo. El valor predeterminado es 2000 para el algoritmo 'active-set' y 200 para los otros algoritmos. Para optimset, el nombre de opción es MaxIter. Consulte Nombres de opciones actuales y antiguos.

Opciones del algoritmo trust-region-reflective

FunctionTolerance	Tolerancia de terminación en el valor de la función, un escalar positivo. El valor predeterminado es 100*eps, aproximadamente 2.2204e-14. Para optimset, el nombre de opción es TolFun. Consulte Nombres de opciones actuales y antiguos.
JacobianMultiplyFcn	Función de multiplicación de matriz jacobiana, especificada como un identificador de función. Para problemas estructurados a gran escala, esta función debería calcular el producto de la matriz jacobiana C*Y, C'*Y o C'*(C*Y) sin formar C. Escriba la función con el formato W = jmfun(Jinfo,Y,flag) donde Jinfo contiene una matriz utilizada para calcular C*Y (o C'*Y, o C'*(C*Y)). jmfun debe calcular uno de los tres productos diferentes, dependiendo del valor de flag que pasa lsqlin: Si flag == 0, entonces W = C'*(C*Y). Si flag > 0, entonces W = C*Y. Si flag < 0, entonces W = C'*Y. En cada caso, no es necesario que jmfun forme C explícitamente. lsqlin utiliza Jinfo para calcular el precondicionador. Consulte Pasar parámetros adicionales para obtener más información sobre cómo proporcionar parámetros adicionales si fuera necesario. Para ver un ejemplo, consulte Jacobian Multiply Function with Linear Least Squares. Para optimset, el nombre de opción es JacobMult. Consulte Nombres de opciones actuales y antiguos.
MaxPCGIter	Número máximo de iteraciones PCG (gradiente conjugado precondicionado), un escalar positivo. La opción predeterminada es max(1,floor(numberOfVariables/2)). Para obtener más información, consulte Algoritmo trust-region-reflective.
OptimalityTolerance	Tolerancia de terminación en la optimalidad de primer orden, un escalar positivo. El valor predeterminado es 100*eps, aproximadamente 2.2204e-14. Consulte Medida de optimalidad de primer orden. Para optimset, el nombre de opción es TolFun. Consulte Nombres de opciones actuales y antiguos.
PrecondBandWidth	Ancho de banda superior del precondicionador para PCG (gradiente conjugado precondicionado). De forma predeterminada, se utiliza precondicionamiento diagonal (ancho de banda superior de 0). Para algunos problemas, aumentar el ancho de banda reduce el número de iteraciones PCG. Estableciendo PrecondBandWidth en Inf se utiliza una factorización directa (Cholesky) en lugar de los gradientes conjugados (CG). La factorización directa es más costosa computacionalmente que CG, pero produce un paso de mejor calidad hacia la solución. Para obtener más información, consulte Algoritmo trust-region-reflective.
SubproblemAlgorithm	Determina cómo se calcula el paso de iteración. La opción predeterminada, 'cg', realiza un paso más rápido, pero menos preciso que 'factorization'. Consulte Mínimos cuadrados trust-region-reflective.
TolPCG	Tolerancia de terminación en la iteración PCG (gradiente conjugado precondicionado), un escalar positivo. La opción predeterminada es 0.1.
TypicalX	Valores x típicos. El número de elementos en TypicalX es igual al número de variables. El valor predeterminado es ones(numberofvariables,1). lsqlin utiliza TypicalX internamente para el escalado. TypicalX solo tiene efecto cuando x tiene componentes desacotados y cuando un valor TypicalX para un componente desacotado es mayor que 1.

Opciones del algoritmo interior-point

ConstraintTolerance	Tolerancia en la vulneración de restricciones, un escalar positivo. La opción predeterminada es 1e-8. Para optimset, el nombre de opción es TolCon. Consulte Nombres de opciones actuales y antiguos.
LinearSolver	Tipo de solver lineal interno en el algoritmo: 'auto' (valor predeterminado): utiliza 'sparse' si la matriz C es dispersa, 'dense' si no lo es. 'sparse': utiliza álgebra lineal dispersa. Consulte Matrices dispersas. 'dense': utiliza álgebra lineal densa.
OptimalityTolerance	Tolerancia de terminación en la optimalidad de primer orden, un escalar positivo. La opción predeterminada es 1e-8. Consulte Medida de optimalidad de primer orden. Para optimset, el nombre de opción es TolFun. Consulte Nombres de opciones actuales y antiguos.
StepTolerance	Tolerancia de terminación en x, un escalar positivo. La opción predeterminada es 1e-12. Para optimset, el nombre de opción es TolX. Consulte Nombres de opciones actuales y antiguos.

Opciones del algoritmo 'active-set'

ConstraintTolerance	Tolerancia en la vulneración de restricciones, un escalar positivo. El valor predeterminado es 1e-8. Para optimset, el nombre de opción es TolCon. Consulte Nombres de opciones actuales y antiguos.
ObjectiveLimit	Una tolerancia (criterio de detención) que es un escalar. Si el valor de la función objetivo es inferior a ObjectiveLimit y el punto actual es factible, las iteraciones se detienen porque se supone que el problema está desacotado. El valor predeterminado es -1e20.
OptimalityTolerance	Tolerancia de terminación en la optimalidad de primer orden, un escalar positivo. El valor predeterminado es 1e-8. Consulte Medida de optimalidad de primer orden. Para optimset, el nombre es TolFun. Consulte Nombres de opciones actuales y antiguos.
StepTolerance	Tolerancia de terminación en x, un escalar positivo. El valor predeterminado es 1e-8. Para optimset, el nombre de opción es TolX. Consulte Nombres de opciones actuales y antiguos.

problem — Problema de optimización

estructura

Problema de optimización, especificado como una estructura con los siguientes campos.

C	Multiplicador de matriz en el término C*x - d
d	Constante aditiva en el término C*x - d
Aineq	Matriz para restricciones de desigualdad lineales
bineq	Vector para restricciones de desigualdad lineales
Aeq	Matriz para restricciones de igualdad lineales
beq	Vector para restricciones de igualdad lineales
lb	Vector de límites inferiores
ub	Vector de límites superiores
x0	Punto inicial para x
solver	'lsqlin'
options	Opciones creadas con optimoptions

Nota

No puede utilizar el arranque en caliente con el argumento problem.

Tipos de datos: struct

ws — Objeto de arranque en caliente

objeto creado utilizando optimwarmstart

Objeto de arranque en caliente, especificado como objeto creado utilizando optimwarmstart. El objeto de arranque en caliente contiene el punto de inicio y opciones, además de datos opcionales para el tamaño de memoria en la generación de código. Consulte Warm Start Best Practices.

Ejemplo: ws = optimwarmstart(x0,options)

Argumentos de salida

x — Solución

vector real

Solución, devuelta como un vector que minimiza la norma de C*x-d sujeta a todos los límites y restricciones lineales.

wsout — Solución de objeto de arranque en caliente

Objeto LsqlinWarmStart

Solución de objeto de arranque en caliente, devuelta como objeto LsqlinWarmStart. El punto de solución es wsout.X.

Puede utilizar wsout como el objeto de entrada de arranque en caliente en una llamada lsqlin posterior.

resnorm — Valor objetivo

escalar real

Valor objetivo, devuelto como el valor escalar norm(C*x-d)^2.

residual — Valores residuales de la solución

vector real

Valores residuales de la solución, devueltos como el vector C*x-d.

exitflag — Condición de detención de algoritmo

valor entero

Condición de detención de algoritmo, devuelta como un entero que identifica la razón por la que el algoritmo se detuvo. A continuación, se enumeran los valores de exitflag y las razones correspondientes por las que lsqlin se detuvo.

3	El cambio en el valor residual fue menor que la tolerancia especificada options.FunctionTolerance. (Algoritmo trust-region-reflective)
2	Tamaño de paso menor que options.StepTolerance y se cumplen las restricciones. (Algoritmo interior-point)
1	La función ha convergido a una solución x.
0	El número de iteraciones ha sobrepasado options.MaxIterations.
-2	El problema no es factible. O, para el algoritmo interior-point, tamaño de paso menor que options.StepTolerance, pero no se cumplen las restricciones.
-3	El problema está desacotado.
-4	Las condiciones mal definidas no permiten seguir optimizando.
-8	No se ha podido calcular una dirección de paso.

El mensaje de salida para el algoritmo interior-point puede proporcionar más detalles sobre la razón por la que lsqlin se detuvo, como sobrepasar la tolerancia. Consulte Indicadores de salida y mensajes de salida.

output — Resumen de un proceso de resolución

estructura

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

iterations	Número de iteraciones que necesitó el solver.
algorithm	Uno de estos algoritmos: 'interior-point' 'trust-region-reflective' 'mldivide' para un problema no restringido Para un problema no restringido, iterations = 0, y las entradas restantes en la estructura output están vacías.
constrviolation	Vulneración de restricciones que es positiva para las restricciones vulneradas (no devuelta para el algoritmo 'trust-region-reflective'). constrviolation = max([0;norm(Aeq*x-beq, inf);(lb-x);(x-ub);(A*x-b)])
message	Mensaje de salida.
firstorderopt	Optimalidad de primer orden en la solución. Consulte Medida de optimalidad de primer orden.
linearsolver	Tipo de solver lineal interno, 'dense' o 'sparse' (solo algoritmo 'interior-point')
cgiterations	Número de iteraciones de gradiente conjugado que realizó el solver. Valor no vacío solo para el algoritmo 'trust-region-reflective'.

Consulte Estructuras de salida.

lambda — Multiplicadores de Lagrange

estructura

Multiplicadores de Lagrange, devueltos como una estructura con los siguientes campos.

lower	Límites inferiores lb
upper	Límites superiores ub
ineqlin	Desigualdades lineales
eqlin	Igualdades lineales

Consulte Estructuras de multiplicadores de Lagrange.

Sugerencias

• Para problemas sin restricciones, puede usar mldivide (división izquierda de matriz). Cuando no tiene restricciones, lsqlin devuelve x = C\d.

• Dado que el problema que se está resolviendo siempre es convexo, lsqlin encuentra una solución global, aunque no necesariamente única.

• Si su problema tiene muchas restricciones lineales y pocas variables, pruebe a usar el algoritmo 'active-set'. Consulte Quadratic Programming with Many Linear Constraints.

• Es probable conseguir resultados numéricos mejores si especifica las igualdades explícitamente, utilizando Aeq y beq en lugar de implícitamente, utilizando lb y ub.

• El algoritmo trust-region-reflective no permite límites superiores e inferiores iguales. Utilice otro algoritmo para este caso.

• Si los límites de entrada especificados para un problema son inconsistentes, la salida x es x0 y las salidas resnorm y residual son [].

• Puede resolver algunos problemas estructurados grandes, incluidos aquellos donde la matriz C es demasiado grande para caber en la memoria, usando el algoritmo trust-region-reflective con una función de multiplicación de matriz jacobiana. Para obtener información, consulte Opciones del algoritmo trust-region-reflective.

Algoritmos

Algoritmo trust-region-reflective

Este método es un método de región de confianza de subespacio basado en el método de Newton de reflejo de punto interior descrito en [1]. Cada iteración implica la solución aproximada de un sistema lineal amplio utilizando el método de gradientes conjugados precondicionados (PCG). Consulte Mínimos cuadrados trust-region-reflective y, en particular, Mínimos cuadrados lineales a gran escala.

Algoritmo interior-point

El algoritmo 'interior-point' está basado en el algoritmo 'interior-point-convex' de quadprog. Consulte Mínimos cuadrados lineales: interior-point o active-set.

Algoritmo de conjunto activo

El algoritmo 'active-set' está basado en el algoritmo 'active-set' de quadprog. Para obtener más información, consulte Mínimos cuadrados lineales: interior-point o active-set y active-set quadprog Algorithm.

Referencias

[1] Coleman, T. F. and Y. Li. “A Reflective Newton Method for Minimizing a Quadratic Function Subject to Bounds on Some of the Variables,” SIAM Journal on Optimization, Vol. 6, Number 4, pp. 1040–1058, 1996.

[2] Gill, P. E., W. Murray, and M. H. Wright. Practical Optimization, Academic Press, London, UK, 1981.

Arranque en caliente

Un objeto de arranque en caliente mantiene una lista de restricciones activas del problema resuelto previamente. El solver guarda tanta información activa de la restricción como sea posible para resolver el problema actual. Si el problema previo es demasiado diferente al actual, no se utiliza ningún conjunto de información activo. En este caso, en la práctica, el solver ejecuta un arranque en frío para restaurar la lista de restricciones activas.

Funcionalidad alternativa

App

La tarea Optimize de Live Editor proporciona una interfaz visual para lsqlin.

Capacidades ampliadas

Generación de código C/C++

Genere código C y C++ mediante MATLAB® Coder™.

Notas y limitaciones de uso:

• lsqlin admite generar código utilizando la función codegen (MATLAB Coder) o la app MATLAB^® Coder™. Debe disponer de una licencia de MATLAB Coder para generar código.

• El hardware de destino debe ser compatible con los cálculos estándar de punto flotante de doble precisión. No puede generar código para cálculos de precisión simple o de punto fijo.

• Los destinos de generación de código no utilizan las mismas bibliotecas del núcleo matemático que los solvers de MATLAB. Por ello, las soluciones de generación de código pueden variar con respecto a las soluciones de solver, especialmente en problemas que no están bien condicionados.

• Cuando resuelva problemas no restringidos y subdeterminados en MATLAB, lsqlin llama a mldivide, que devuelve una solución básica. En la generación de código, la solución devuelta tiene una norma mínima, que suele diferir.

• lsqlin no es compatible con el argumento problem para generar código.

  [x,fval] = lsqlin(problem) % Not supported

• Todas las matrices de entrada lsqlin, como A, Aeq, lb y ub, deben ser matrices llenas, no dispersas. Puede convertir las matrices dispersas en matrices llenas mediante la función full.

• Los argumentos lb y ub deben tener el mismo número de entradas que el número de columnas de C o deben estar vacíos [].

• Si su hardware de destino no admite límites infinitos, utilice optim.coder.infbound.

• Para optimizar código de manera avanzada con procesadores integrados, también necesita una licencia de Embedded Coder^®.

• Debe incluir opciones para lsqlin y especificarlas utilizando optimoptions. Las opciones deben incluir la opción Algorithm, establecida en 'active-set'.

  options = optimoptions('lsqlin','Algorithm','active-set');
  [x,fval,exitflag] = lsqlin(C,d,A,b,Aeq,beq,lb,ub,x0,options);

• La generación de código es compatible con estas opciones:

  • Algorithm: debe ser 'active-set'

  • ConstraintTolerance

  • MaxIterations

  • ObjectiveLimit

  • OptimalityTolerance

  • StepTolerance

• El código generado tiene verificación de errores limitada para opciones. La forma recomendada para actualizar una opción es utilizar optimoptions, no notación de puntos.

  opts = optimoptions('lsqlin','Algorithm','active-set');
  opts = optimoptions(opts,'MaxIterations',1e4); % Recommended
  opts.MaxIterations = 1e4; % Not recommended

• No cargue opciones desde un archivo, ya que la generación de código podría fallar. En su lugar, cree opciones en el código.

• Si especifica una opción no compatible, dicha opción se ignora típicamente durante la generación de código. Para obtener unos resultados más fiables, especifique únicamente opciones compatibles.

Historial de versiones

Introducido antes de R2006a

Consulte también

mldivide | lsqnonneg | quadprog | Optimize | optimwarmstart

Temas

• Nonnegative Linear Least Squares, Solver-Based
• Optimize Live Editor Task with lsqlin Solver
• Jacobian Multiply Function with Linear Least Squares
• Warm Start Best Practices
• Algoritmos de mínimos cuadrados (ajuste de modelos)