Main Content

La traducción de esta página está obsoleta. Haga clic aquí para ver la última versión en inglés.

fsolve

Resuelva un sistema de ecuaciones no lineales

Descripción

Solver de sistema no lineal

Resuelve un problema especificado por

F(x) = 0

para x, donde F (x) es una función que devuelve un valor de vector.

x es un vector o una matriz; consulte Argumentos de matriz.

ejemplo

x = fsolve(fun,x0) comienza en x0 e intenta resolver las ecuaciones fun(x) = 0, un arreglo de ceros.

Nota

Pasar parámetros adicionales explica cómo pasar parámetros adicionales a la función vectorial fun(x), si fuera necesario. Consulte Resolver una ecuación parametrizada.

ejemplo

x = fsolve(fun,x0,options) resuelve las ecuaciones con las opciones de optimización especificadas en options. Utilice optimoptions para configurar estas opciones.

ejemplo

x = fsolve(problem) resuelve problem, una estructura descrita en problem.

ejemplo

[x,fval] = fsolve(___), para cualquier sintaxis, devuelve el valor de la función objetivo fun en la solución x.

ejemplo

[x,fval,exitflag,output] = fsolve(___), devuelve adicionalmente un valor exitflag que describe la condición de salida de fsolve y una estructura output con información sobre el proceso de optimización.

[x,fval,exitflag,output,jacobian] = fsolve(___) devuelve la matriz jacobiana de fun en la solución x.

Ejemplos

contraer todo

Este ejemplo muestra cómo resolver dos ecuaciones no lineales en dos variables. Las ecuaciones son

$$ \begin{array}{c}
{e^{ - {e^{ - ({x_1} + {x_2})}}}} = {x_2}\left( {1 + x_1^2} \right)\\
{x_1}\cos \left( {{x_2}} \right) + {x_2}\sin \left( {{x_1}} \right) = \frac{1}{2}.
\end{array} $$

Convierta las ecuaciones al formato $F(x) = \bf{0}$.

$$\begin{array}{c}
{e^{ - {e^{ - ({x_1} + {x_2})}}}} - {x_2}\left( {1 + x_1^2} \right) = 0\\
{x_1}\cos \left( {{x_2}} \right) + {x_2}\sin \left( {{x_1}} \right)
- \frac{1}{2} = 0. \end{array} $$

Escriba una función que calcule el lado izquierdo de estas dos ecuaciones.

function F = root2d(x)

F(1) = exp(-exp(-(x(1)+x(2)))) - x(2)*(1+x(1)^2);
F(2) = x(1)*cos(x(2)) + x(2)*sin(x(1)) - 0.5;

Guarde este código como un archivo llamado root2d.m en la ruta de MATLAB®.

Resuelva el sistema de ecuaciones comenzando en el punto [0,0].

fun = @root2d;
x0 = [0,0];
x = fsolve(fun,x0)
Equation solved.

fsolve completed because the vector of function values is near zero
as measured by the value of the function tolerance, and
the problem appears regular as measured by the gradient.


x =

    0.3532    0.6061

Examine el proceso de resolución para un sistema no lineal.

Establezca las opciones de forma que no cuente con visualización y cuente con una función de gráfica que muestre la optimalidad de primer orden, que debería converger a 0 a medida que el algoritmo itera.

options = optimoptions('fsolve','Display','none','PlotFcn',@optimplotfirstorderopt);

Las ecuaciones del sistema no lineal son

$$\begin{array}{c}
{e^{ - {e^{ - ({x_1} + {x_2})}}}} = {x_2}\left( {1 + x_1^2} \right)\\
{x_1}\cos \left( {{x_2}} \right) + {x_2}\sin \left( {{x_1}} \right) = \frac{1}{2}.
\end{array} $$

Convierta las ecuaciones al formato $F(x) = \bf{0}$.

$$\begin{array}{c}
{e^{ - {e^{ - ({x_1} + {x_2})}}}} - {x_2}\left( {1 + x_1^2} \right) = 0\\
{x_1}\cos \left( {{x_2}} \right) + {x_2}\sin \left( {{x_1}} \right)
- \frac{1}{2} = 0. \end{array} $$

Escriba una función que calcule el lado izquierdo de estas dos ecuaciones.

function F = root2d(x)

F(1) = exp(-exp(-(x(1)+x(2)))) - x(2)*(1+x(1)^2);
F(2) = x(1)*cos(x(2)) + x(2)*sin(x(1)) - 0.5;

Guarde este código como un archivo llamado root2d.m en la ruta de MATLAB®.

Resuelva el sistema no lineal comenzando por el punto [0,0] y observe el proceso de resolución.

fun = @root2d;
x0 = [0,0];
x = fsolve(fun,x0,options)
x =

    0.3532    0.6061

Puede parametrizar ecuaciones tal y como se describe en la sección Pasar parámetros adicionales. Por ejemplo, la función auxiliar paramfun al final de este ejemplo crea el siguiente sistema de ecuación parametrizado por c:

2x1+x2=exp(cx1)-x1+2x2=exp(cx2).

Para resolver el sistema para un valor particular, en este caso c=-1, establezca c en el espacio de trabajo y cree una función anónima en x desde paramfun.

c = -1;
fun = @(x)paramfun(x,c);

Resuelva el sistema comenzando por el punto x0 = [0 1].

x0 = [0 1];
x = fsolve(fun,x0)
Equation solved.

fsolve completed because the vector of function values is near zero
as measured by the value of the function tolerance, and
the problem appears regular as measured by the gradient.
x = 1×2

    0.1976    0.4255

Para la resolución con un valor diferente de c, introduzca c en el espacio de trabajo y cree la función fun de nuevo para que tenga el nuevo valor c.

c = -2;
fun = @(x)paramfun(x,c); % fun now has the new c value
x = fsolve(fun,x0)
Equation solved.

fsolve completed because the vector of function values is near zero
as measured by the value of the function tolerance, and
the problem appears regular as measured by the gradient.
x = 1×2

    0.1788    0.3418

Función auxiliar

Este código crea la función auxiliar paramfun.

function F = paramfun(x,c)
F = [ 2*x(1) + x(2) - exp(c*x(1))
      -x(1) + 2*x(2) - exp(c*x(2))];
end

Cree una estructura de problema para fsolve y resuelva el problema.

Resuelva el mismo problema que en Resolución con opciones no predeterminadas, pero formule el problema utilizando una estructura de problema.

Establezca las opciones para el problema de forma que no cuente con visualización y cuente con una función de gráfica que muestre la optimalidad de primer orden, que debería converger a 0 a medida que el algoritmo itera.

problem.options = optimoptions('fsolve','Display','none','PlotFcn',@optimplotfirstorderopt);

Las ecuaciones del sistema no lineal son

$$\begin{array}{c}
{e^{ - {e^{ - ({x_1} + {x_2})}}}} = {x_2}\left( {1 + x_1^2} \right)\\
{x_1}\cos \left( {{x_2}} \right) + {x_2}\sin \left( {{x_1}} \right) = \frac{1}{2}.
\end{array} $$

Convierta las ecuaciones al formato $F(x) = \bf{0}$.

$$\begin{array}{c}
{e^{ - {e^{ - ({x_1} + {x_2})}}}} - {x_2}\left( {1 + x_1^2} \right) = 0\\
{x_1}\cos \left( {{x_2}} \right) + {x_2}\sin \left( {{x_1}} \right)
- \frac{1}{2} = 0. \end{array} $$

Escriba una función que calcule el lado izquierdo de estas dos ecuaciones.

function F = root2d(x)

F(1) = exp(-exp(-(x(1)+x(2)))) - x(2)*(1+x(1)^2);
F(2) = x(1)*cos(x(2)) + x(2)*sin(x(1)) - 0.5;

Guarde este código como un archivo llamado root2d.m en la ruta de MATLAB®.

Cree los campos restantes en la estructura de problema.

problem.objective = @root2d;
problem.x0 = [0,0];
problem.solver = 'fsolve';

Resuelva el problema.

x = fsolve(problem)
x =

    0.3532    0.6061

Este ejemplo devuelve la visualización iterativa que muestra el proceso de resolución para el sistema de dos ecuaciones y dos incógnitas

2x1-x2=e-x1-x1+2x2=e-x2.

Reescriba las ecuaciones con el formato F(x) = 0:

2x1-x2-e-x1=0-x1+2x2-e-x2=0.

Comience a buscar una solución en x0 = [-5 -5].

En primer lugar, escriba una función que calcule F, los valores de las ecuaciones en x.

F = @(x) [2*x(1) - x(2) - exp(-x(1));
         -x(1) + 2*x(2) - exp(-x(2))];

Cree el punto inicial x0.

x0 = [-5;-5];

Establezca opciones para devolver una visualización iterativa.

options = optimoptions('fsolve','Display','iter');

Resuelva las ecuaciones.

[x,fval] = fsolve(F,x0,options)
                                         Norm of      First-order   Trust-region
 Iteration  Func-count     f(x)          step         optimality    radius
     0          3         47071.2                      2.29e+04               1
     1          6         12003.4              1       5.75e+03               1
     2          9         3147.02              1       1.47e+03               1
     3         12         854.452              1            388               1
     4         15         239.527              1            107               1
     5         18         67.0412              1           30.8               1
     6         21         16.7042              1           9.05               1
     7         24         2.42788              1           2.26               1
     8         27        0.032658       0.759511          0.206             2.5
     9         30     7.03149e-06       0.111927        0.00294             2.5
    10         33     3.29525e-13     0.00169132       6.36e-07             2.5

Equation solved.

fsolve completed because the vector of function values is near zero
as measured by the value of the function tolerance, and
the problem appears regular as measured by the gradient.
x = 2×1

    0.5671
    0.5671

fval = 2×1
10-6 ×

   -0.4059
   -0.4059

La visualización iterativa muestra f(x), que es el cuadrado de la norma de la función F(x). Este valor se reduce casi a cero a medida que se realizan las iteraciones. La medida de optimalidad de primer orden también se reduce casi a cero a medida que se realizan las iteraciones. Estas entradas muestran la convergencia de las iteraciones a una solución. Para saber cuál es el significado de las otras entradas, consulte Iterative Display.

La salida fval proporciona el valor de función F(x), que debería ser cero en una solución (dentro de la tolerancia FunctionTolerance).

Encuentre una matriz X que satisfaga

X*X*X=[1234],

comenzando en el punto x0 = [1,1;1,1]. Cree una función anónima que calcule la ecuación de matriz y cree el punto x0.

fun = @(x)x*x*x - [1,2;3,4];
x0 = ones(2);

Establezca las opciones de forma que no cuente con visualización.

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

Examine las salidas de fsolve para ver la calidad de la solución y el proceso.

[x,fval,exitflag,output] = fsolve(fun,x0,options)
x = 2×2

   -0.1291    0.8602
    1.2903    1.1612

fval = 2×2
10-9 ×

   -0.1618    0.0778
    0.1160   -0.0474

exitflag = 1
output = struct with fields:
       iterations: 6
        funcCount: 35
        algorithm: 'trust-region-dogleg'
    firstorderopt: 2.4095e-10
          message: '...'

El valor de indicador de salida 1 muestra que la solución es fiable. Para verificarlo de forma manual, calcule el valor residual (suma de los cuadrados de fval) para comprobar lo cerca que está de cero.

sum(sum(fval.*fval))
ans = 4.7957e-20

El valor residual pequeño confirma que x es una solución.

En la estructura de output puede ver cuántas iteraciones y evaluaciones de función ha realizado fsolve para encontrar la solución.

Argumentos de entrada

contraer todo

Ecuaciones no lineales que se desea resolver, especificadas como un identificador de función o un nombre de función. fun es una función que acepta un vector x y devuelve un vector F, con las ecuaciones no lineales evaluadas en x. Las ecuaciones que se desea resolver son F = 0 para todos los componentes de F. La función fun puede especificarse como un identificador de función para un archivo

x = fsolve(@myfun,x0)

donde myfun es una función de MATLAB® como

function F = myfun(x)
F = ...            % Compute function values at x

fun también puede ser un identificador de función para una función anónima.

x = fsolve(@(x)sin(x.*x),x0);

fsolve pasa x a su función objetivo en forma de argumento x0. Por ejemplo, si x0 es un arreglo de 5 por 3, fsolve pasa x a fun como un arreglo de 5 por 3.

Si la matriz jacobiana también puede calcularse y la opción 'SpecifyObjectiveGradient' es true, configurado mediante

options = optimoptions('fsolve','SpecifyObjectiveGradient',true)

en un segundo argumento de salida, la función fun debe devolver el valor jacobiano J, una matriz, en x.

Si fun devuelve un vector (matriz) de m componentes y x tiene una longitud de n, donde n es la longitud de x0, la matriz jacobiana J es una matriz de m por n donde J(i,j) es la derivada parcial de F(i) con respecto a x(j). (La matriz jacobiana J es la traspuesta del gradiente de F).

Ejemplo: fun = @(x)x*x*x-[1,2;3,4]

Tipos de datos: char | function_handle | string

Punto inicial, especificado como un vector real o un arreglo real. fsolve utiliza el número de elementos en x0 y su tamaño para determinar el número y el tamaño de las variables que fun acepta.

Ejemplo: x0 = [1,2,3,4]

Tipos de datos: double

Opciones de optimización, especificadas como la salida de optimoptions o una estructura como la que devuelve optimset.

Algunas opciones son aplicables a todos los algoritmos y otras son relevantes para algoritmos particulares. Consulte Optimization Options Reference para ver información detallada.

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 Visualizar opciones.

Todos los algoritmos
Algorithm

Escoja entre 'trust-region-dogleg' (opción predeterminada), 'trust-region' y 'levenberg-marquardt'.

La opción Algorithm especifica una preferencia sobre qué algoritmo utilizar. Se trata únicamente de una preferencia porque, para el algoritmo trust-region, no se puede subdeterminar el sistema de ecuaciones no lineales; es decir, el número de ecuaciones (el número de elementos de F devuelto por fun) debe ser, al menos, el mismo que la longitud de x. De forma similar, para el algoritmo trust-region-dogleg, el número de ecuaciones debe ser el mismo que la longitud de x. fsolve utiliza el algoritmo Levenberg-Marquardt cuando el algoritmo seleccionado no está disponible. Para obtener más información sobre cómo elegir el algoritmo, consulte Choosing the Algorithm.

Para configurar algunas opciones de algoritmo utilizando optimset en lugar de optimoptions:

  • Algorithm: establezca el algoritmo en 'trust-region-reflective' en lugar de 'trust-region'.

  • InitDamping: configure el parámetro inicial λ de Levenberg-Marquardt estableciendo Algorithm en un arreglo de celdas como {'levenberg-marquardt',.005}.

CheckGradients

Compare las derivadas proporcionadas por el usuario (gradientes de objetivo o de restricciones) con las derivadas de diferencias finitas. Las opciones son true o la opción predeterminada false.

Para optimset, el nombre es DerivativeCheck y los valores son 'on' u 'off'. Consulte Nombres de opciones actuales y antiguos.

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'.

DiffMaxChange

Cambio máximo en variables para gradientes de diferencias finitas (un escalar positivo). La opción predeterminada es Inf.

DiffMinChange

Cambio mínimo en variables para gradientes de diferencias finitas (un escalar positivo). La opción predeterminada es 0.

Display

Nivel de visualización (consulte Iterative Display):

  • 'off' o 'none' no muestran salida alguna.

  • 'iter' muestra la salida en cada iteración y emite el mensaje de salida predeterminado.

  • 'iter-detailed' muestra la salida en cada iteración y emite el mensaje de salida técnico.

  • 'final' (opción predeterminada) solo muestra la salida final y emite el mensaje de salida predeterminado.

  • 'final-detailed' solo muestra la salida final y emite el mensaje de salida técnico.

FiniteDifferenceStepSize

Factor de tamaño de salto de escalar o vector para diferencias finitas. Cuando establece FiniteDifferenceStepSize en un vector v, las diferencias finitas progresivas delta son

delta = v.*sign′(x).*max(abs(x),TypicalX);

, donde sign′(x) = sign(x) excepto sign′(0) = 1. Las diferencias finitas centrales son

delta = v.*max(abs(x),TypicalX);

El escalar FiniteDifferenceStepSize se expande a un vector. La opción predeterminada es sqrt(eps) para diferencias finitas progresivas y eps^(1/3) para diferencias finitas centrales.

Para optimset, el nombre es FinDiffRelStep. Consulte Nombres de opciones actuales y antiguos.

FiniteDifferenceType

Las diferencias finitas, utilizadas para estimar gradientes, son o bien 'forward' (opción predeterminada), o bien 'central' (centradas). La opción 'central' requiere el doble de evaluaciones de función, pero debería ser más precisa.

El algoritmo respeta escrupulosamente los límites cuando estima ambos tipos de diferencias finitas. De este modo, por ejemplo, podrá seleccionar una diferencia regresiva en lugar de progresiva para evitar realizar la evaluación en un punto fuera de los límites.

Para optimset, el nombre es FinDiffType. Consulte Nombres de opciones actuales y antiguos.

FunctionTolerance

Tolerancia de terminación en el valor de la función, un escalar positivo. La opción predeterminada es 1e-6. Consulte Tolerancias y criterios de detención.

Para optimset, el nombre es TolFun. Consulte Nombres de opciones actuales y antiguos.

FunValCheck

Compruebe si los valores de la función objetivo son válidos. 'on' muestra un error cuando la función objetivo devuelve un valor complex, Inf o NaN. La opción predeterminada, 'off', no muestra ningún error.

MaxFunctionEvaluations

Número máximo de evaluaciones de función permitidas, un entero positivo. La opción predeterminada es 100*numberOfVariables. Consulte Tolerancias y criterios de detención y Iteraciones y recuentos de la función.

Para optimset, el nombre es MaxFunEvals. Consulte Nombres de opciones actuales y antiguos.

MaxIterations

Número máximo de iteraciones permitidas, un entero positivo. La opción predeterminada es 400. Consulte Tolerancias y criterios de detención y Iteraciones y recuentos de la función.

Para optimset, el nombre es MaxIter. Consulte Nombres de opciones actuales y antiguos.

OptimalityTolerance

Tolerancia de terminación en la optimalidad de primer orden (un escalar positivo). La opción predeterminada es 1e-6. Consulte First-Order Optimality Measure.

Internamente, el algoritmo 'levenberg-marquardt' utiliza una tolerancia de optimalidad (criterio de detención) de 1e-4 multiplicado por la FunctionTolerance y no utiliza OptimalityTolerance.

OutputFcn

Especifique una o varias funciones definidas por el usuario a las que una función de optimización llame en cada iteración. Pase un identificador de función o un arreglo de celdas de identificadores de función. La opción predeterminada es ninguno ([]). Consulte Output Function and Plot Function Syntax.

PlotFcn

Representa varias medidas de progreso mientras el algoritmo se ejecuta; seleccione una de las gráficas predefinidas o escriba la suya propia. Pase un nombre de función de gráfica integrada, un identificador de función o un arreglo de celdas de nombres de función de gráfica integrada o identificadores de función. Para funciones de gráfica personalizadas, pase identificadores de función. La opción predeterminada es ninguno ([]):

  • 'optimplotx' representa el punto actual.

  • 'optimplotfunccount' representa el recuento de la función.

  • 'optimplotfval' representa el valor de la función.

  • 'optimplotstepsize' representa el tamaño de salto.

  • 'optimplotfirstorderopt' representa la medida de optimalidad de primer orden.

Las funciones de gráfica personalizadas utilizan la misma sintaxis que las funciones de salida. Consulte Output Functions for Optimization Toolbox y Output Function and Plot Function Syntax.

Para optimset, el nombre es PlotFcns. Consulte Nombres de opciones actuales y antiguos.

SpecifyObjectiveGradient

Si true, fsolve utiliza una matriz jacobiana definida por el usuario (definida en fun) o información jacobiana (cuando se utiliza JacobianMultiplyFcn) para la función objetivo. Si false (predeterminada), fsolve aproxima la matriz jacobiana utilizando diferencias finitas.

Para optimset, el nombre es Jacobian y los valores son 'on' u 'off'. Consulte Nombres de opciones actuales y antiguos.

StepTolerance

Tolerancia de terminación en x, un escalar positivo. La opción predeterminada es 1e-6. Consulte Tolerancias y criterios de detención.

Para optimset, el nombre es TolX. Consulte Nombres de opciones actuales y antiguos.

TypicalX

Valores x típicos. El número de elementos en TypicalX es igual al número de elementos en x0, el punto de inicio. El valor predeterminado es ones(numberofvariables,1). fsolve utiliza TypicalX para escalar diferencias finitas para la estimación de gradientes.

El algoritmo trust-region-dogleg utiliza TypicalX como los términos diagonales de una matriz de escalado.

UseParallel

Cuando true, fsolve estima gradientes en paralelo. Deshabilite la opción estableciéndola en la opción predeterminada, false. Consulte Computación paralela.

Algoritmo trust-region
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 calcula el producto de la matriz jacobiana J*Y, J'*Y o J'*(J*Y) sin formar J. La función tiene el formato

W = jmfun(Jinfo,Y,flag)

donde Jinfo contiene una matriz utilizada para calcular J*Y (o J'*Y, o J'*(J*Y)). El primer argumento Jinfo debe ser el mismo que el segundo argumento devuelto por la función objetivo fun, por ejemplo, en

[F,Jinfo] = fun(x)

Y es una matriz que tiene el mismo número de filas que dimensiones hay en el problema. flag determina qué producto se calcula:

  • Si flag == 0, W = J'*(J*Y).

  • Si flag > 0, W = J*Y.

  • Si flag < 0, W = J'*Y.

En cada caso, J no se forma explícitamente. fsolve utiliza Jinfo para calcular el precondicionador. Consulte Pasar parámetros adicionales para obtener información sobre cómo proporcionar valores para cualquier parámetro adicional que jmfun necesite.

Nota

'SpecifyObjectiveGradient' debe establecerse en true para que fsolve pase Jinfo de fun a jmfun.

Consulte Minimization with Dense Structured Hessian, Linear Equalities para ver un ejemplo similar.

Para optimset, el nombre es JacobMult. Consulte Nombres de opciones actuales y antiguos.

JacobPattern

Patrón de dispersión de la matriz jacobiana para diferenciación finita. Establezca JacobPattern(i,j) = 1 cuando fun(i) dependa de x(j). De lo contrario, establezca JacobPattern(i,j) = 0. En otras palabras, establezca JacobPattern(i,j) = 1 cuando puede tener ∂fun(i)/∂x(j) ≠ 0.

Utilice JacobPattern cuando no sea conveniente calcular la matriz jacobiana J en fun, aunque pueda determinar (por ejemplo, inspeccionándolo) cuándo fun(i) depende de x(j). fsolve puede aproximar J mediante diferencias finitas dispersas cuando proporciona JacobPattern.

En el peor de los casos, si la estructura es desconocida, no establezca JacobPattern. El comportamiento predeterminado es como si JacobPattern fuera una matriz densa de unos. Entonces, fsolve calcula una aproximación completa de diferencias finitas en cada iteración. Esto puede ser muy costoso para problemas grandes, por lo que normalmente es mejor determinar la estructura de dispersión.

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 Equation Solving Algorithms.

PrecondBandWidth

Ancho de banda superior del precondicionador para PCG, un entero no negativo. La opción predeterminada de PrecondBandWidth es Inf, lo que implica que 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 salto de mejor calidad hacia la solución. Establezca PrecondBandWidth en 0 para precondicionamiento diagonal (ancho de banda superior de 0). Para algunos problemas, un ancho de banda intermedio reduce el número de iteraciones PCG.

SubproblemAlgorithm

Determina cómo se calcula el salto de iteración. La opción predeterminada, 'factorization', realiza un salto más lento, pero más preciso que 'cg'. Consulte Trust-Region Algorithm.

TolPCG

Tolerancia de terminación en la iteración PCG, un escalar positivo. La opción predeterminada es 0.1.

Algoritmo Levenberg-Marquardt
InitDamping

Valor inicial del parámetro de Levenberg-Marquardt, un escalar positivo. La opción predeterminada es 1e-2. Para obtener más detalles, consulte Levenberg-Marquardt Method.

ScaleProblem

'jacobian' puede, en ocasiones, mejorar la convergencia de un problema que no esté bien escalado. La opción predeterminada es 'none'.

Ejemplo: options = optimoptions('fsolve','FiniteDifferenceType','central')

Estructura de problema, especificada como una estructura con los siguientes campos:

Nombre de campoEntrada

objective

Función objetivo

x0

Punto inicial para x

solver

'fsolve'

options

Opciones creadas con optimoptions

Tipos de datos: struct

Argumentos de salida

contraer todo

Solución, devuelta como un vector real o un arreglo real. El tamaño de x es el mismo que el tamaño de x0. Habitualmente, x es una solución local al problema cuando exitflag es positivo. Para obtener información sobre la calidad de la solución, consulte When the Solver Succeeds.

Valor de la función objetivo en la solución, devuelto como un vector real. Por lo general, fval = fun(x).

Razón por la que fsolve se ha detenido, devuelta como un entero.

1

Ecuación resuelta. La optimalidad de primer orden es pequeña.

2

Ecuación resuelta. El cambio en x es menor que la tolerancia especificada o la matriz jacobiana en x no está definida.

3

Ecuación resuelta. El cambio en el valor residual es menor que la tolerancia especificada.

4

Ecuación resuelta. La magnitud de la dirección de búsqueda es menor que la tolerancia especificada.

0

El número de iteraciones ha sobrepasado options.MaxIterations o el número de evaluaciones de función ha sobrepasado options.MaxFunctionEvaluations.

-1

La función de salida o la función de gráfica ha detenido el algoritmo.

-2

Ecuación no resuelta. El mensaje de salida puede contener más información.

-3

Ecuación no resuelta. El radio de la región de confianza se ha vuelto demasiado pequeño (algoritmo trust-region-dogleg).

Información sobre el proceso de optimización, devuelta como estructura con campos:

iterations

Número de iteraciones realizadas

funcCount

Número de evaluaciones de función

algorithm

Algoritmo de optimización utilizado

cgiterations

Número total de iteraciones PCG (solo algoritmo 'trust-region')

stepsize

Desplazamiento final en x (no en 'trust-region-dogleg')

firstorderopt

Medida de optimalidad de primer orden

message

Mensaje de salida

Matriz jacobiana en la solución, devuelta como una matriz real. jacobian(i,j) es la derivada parcial de fun(i) con respecto a x(j) en la solución x.

Limitaciones

  • La función que se desea resolver debe ser continua.

  • Cuando se resuelve correctamente, fsolve solo proporciona una raíz.

  • El método predeterminado trust-region dogleg solo puede utilizarse cuando el sistema de ecuaciones es cuadrado, es decir, el número de ecuaciones es igual al número de incógnitas. Para el método de Levenberg-Marquardt, no es necesario que el sistema de ecuaciones sea cuadrado.

Sugerencias

  • Para problemas grandes, es decir, aquellos con miles de variables o incluso más, puede ahorrar memoria (y posiblemente tiempo) estableciendo la opción Algorithm en 'trust-region' y la opción SubproblemAlgorithm en 'cg'.

Algoritmos

Los métodos Levenberg-Marquardt y trust-region se basan en los algoritmos de mínimos cuadrados no lineales que también se utilizan en lsqnonlin. Utilice uno de estos métodos si es posible que el sistema no tenga un cero. El algoritmo sigue devolviendo un punto donde el valor residual es pequeño. No obstante, si la matriz jacobiana del sistema es singular, el algoritmo puede converger a un punto que no sea una solución del sistema de ecuaciones (consulte Limitaciones).

  • De forma predeterminada, fsolve escoge el algoritmo trust-region dogleg. El algoritmo es una variante del método dogleg de Powell descrito en [8]. Es similar al algoritmo implementado en [7]. Consulte Trust-Region-Dogleg Algorithm.

  • El algoritmo trust-region es un método de región de confianza de subespacio y se basa en el método de Newton de reflejo de punto interior descrito en [1] y [2]. Cada iteración implica la solución aproximada de un sistema lineal amplio utilizando el método de gradientes conjugados precondicionados (PCG). Consulte Trust-Region Algorithm.

  • El método de Levenberg-Marquardt se describe en las referencias [4], [5] y [6]. Consulte Levenberg-Marquardt Method.

Funcionalidad alternativa

App

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

Referencias

[1] Coleman, T.F. and Y. Li, “An Interior, Trust Region Approach for Nonlinear Minimization Subject to Bounds,” SIAM Journal on Optimization, Vol. 6, pp. 418-445, 1996.

[2] Coleman, T.F. and Y. Li, “On the Convergence of Reflective Newton Methods for Large-Scale Nonlinear Minimization Subject to Bounds,” Mathematical Programming, Vol. 67, Number 2, pp. 189-224, 1994.

[3] Dennis, J. E. Jr., “Nonlinear Least-Squares,” State of the Art in Numerical Analysis, ed. D. Jacobs, Academic Press, pp. 269-312.

[4] Levenberg, K., “A Method for the Solution of Certain Problems in Least-Squares,” Quarterly Applied Mathematics 2, pp. 164-168, 1944.

[5] Marquardt, D., “An Algorithm for Least-squares Estimation of Nonlinear Parameters,” SIAM Journal Applied Mathematics, Vol. 11, pp. 431-441, 1963.

[6] Moré, J. J., “The Levenberg-Marquardt Algorithm: Implementation and Theory,” Numerical Analysis, ed. G. A. Watson, Lecture Notes in Mathematics 630, Springer Verlag, pp. 105-116, 1977.

[7] Moré, J. J., B. S. Garbow, and K. E. Hillstrom, User Guide for MINPACK 1, Argonne National Laboratory, Rept. ANL-80-74, 1980.

[8] Powell, M. J. D., “A Fortran Subroutine for Solving Systems of Nonlinear Algebraic Equations,” Numerical Methods for Nonlinear Algebraic Equations, P. Rabinowitz, ed., Ch.7, 1970.

Capacidades ampliadas

Historial de versiones

Introducido antes de R2006a