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.

fsolve

Resolver un sistema de ecuaciones no lineales

Sintaxis

x = fsolve(fun,x0)

x = fsolve(fun,x0,options)

x = fsolve(problem)

[x,fval] = fsolve(___)

[x,fval,exitflag,output] = fsolve(___)

[x,fval,exitflag,output,jacobian] = fsolve(___)

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.

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.

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

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

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

[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

Solución de un sistema no lineal en 2D

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)=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}$$

La función root2d.m, que está disponible cuando se ejecuta este ejemplo, calcula los valores.

type root2d.m

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;

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 = 1×2

    0.3532    0.6061

Resolución con opciones no predeterminadas

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)=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}$$

La función root2d calcula el lado izquierdo de estas dos ecuaciones.

type root2d.m

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;

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 = 1×2

    0.3532    0.6061

Resolver una ecuación parametrizada

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$$:

$$\begin{array}{c}2x_1+x_2=\exp (c{x}_1)\\ -x_1+2x_2=\exp (c{x}_2).\end{array}$$

Para resolver el sistema para un valor particular, en este caso $$c=-1$$, establezca $$c$$ en el área 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 área 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

Resolver una estructura de problema

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)=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}$$

La función root2d calcula el lado izquierdo de estas dos ecuaciones.

type root2d

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;

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 = 1×2

    0.3532    0.6061

Proceso de resolución de un sistema no lineal

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

$$\begin{array}{c}2x_1-x_2=e^{-x_1}\\ -x_1+2x_2=e^{-x_2}.\end{array}$$

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

$$\begin{array}{c}2x_1-x_2-e^{-x_1}=0\\ -x_1+2x_2-e^{-x_2}=0.\end{array}$$

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)||^2           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 Visualización iterativa.

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

Examinar la solución de la ecuación de matriz

Encuentre una matriz $$X$$ que satisfaga

$$X*X*X=\left[\begin{array}{cc}1& 2\\ 3& 4\end{array}\right]$$,

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.2742    0.1258
    0.1876   -0.0864

exitflag = 1

output = struct with fields:
       iterations: 11
        funcCount: 52
        algorithm: 'trust-region-dogleg'
    firstorderopt: 4.0197e-10
          message: 'Equation solved....'

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 = 1.3367e-19

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

fun — Ecuaciones no lineales que se desea resolver

identificador de función | nombre de función

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

x0 — Punto inicial

vector real | arreglo real

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

options — Opciones de optimización

salida de optimoptions | estructura como la que devuelve optimset

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 Referencia de opciones de optimización 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 Consultar las opciones de optimización.

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 Seleccionar el algoritmo. 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. La opción CheckGradients se eliminará en una versión futura. Para comprobar las derivadas, utilice la función checkGradients.
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 Visualización iterativa): '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 paso 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); Un 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. El valor predeterminado es 100*numberOfVariables para los algoritmos 'trust-region-dogleg' y 'trust-region', y 200*numberOfVariables para el algoritmo 'levenberg-marquardt'. 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 Medida de optimalidad de primer orden. Internamente, el algoritmo 'levenberg-marquardt' utiliza una tolerancia de optimalidad (criterio de detención) de 1e-4 veces 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 Sintaxis de función de salida y función de gráfica.
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 paso. '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 Funciones de salida para Optimization Toolbox y Sintaxis de función de salida y función de gráfica. 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 datos utilizados para calcular J*Y (o J'*Y, o J'*(J*Y)). El primer argumento Jinfo es 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 Algoritmos de resolución de ecuaciones.
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 paso 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 paso de iteración. La opción predeterminada, 'factorization', realiza un paso más lento, pero más preciso que 'cg'. Consulte Algoritmo trust-region.
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 Método de Levenberg-Marquardt.
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')

problem — Estructura de problema

estructura

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

Nombre de campo	Entrada
objective	Función objetivo
x0	Punto inicial para x
solver	'fsolve'
options	Opciones creadas con optimoptions

Tipos de datos: struct

Argumentos de salida

x — Solución

vector real | arreglo real

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 Cuando el solver tiene éxito.

fval — Valor de la función objetivo en la solución

vector real

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

exitflag — Razón por la que fsolve se ha detenido

valor entero

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

output — Información sobre el proceso de optimización

estructura

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

jacobian — Matriz jacobiana en la solución

matriz real

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.

Para los problemas con restricciones activas en la solución, jacobian no es útil para estimar intervalos de confianza.

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 Algoritmo trust-region-dogleg.

• 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 Algoritmo trust-region.

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

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

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

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

• fsolve 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.

• Todo el código que se vaya a generar debe ser código de MATLAB. En particular, no puede utilizar una función de caja negra personalizada como una función objetivo para fsolve. Puede utilizar coder.ceval para evaluar una función personalizada con código C o C++. No obstante, la función personalizada debe llamarse en una función de MATLAB.

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

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

• Debe especificar la función objetivo utilizando identificadores de función, no cadenas ni nombres de caracteres.

  x = fsolve(@fun,x0,options) % Supported
  % Not supported: fsolve('fun',...) or fsolve("fun",...)

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

• Debe incluir opciones para fsolve y especificarlas utilizando optimoptions. Las opciones deben incluir la opción Algorithm, establecida en 'levenberg-marquardt'.

  options = optimoptions('fsolve','Algorithm','levenberg-marquardt');
  [x,fval,exitflag] = fsolve(fun,x0,options);

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

  • Algorithm: debe ser 'levenberg-marquardt'

  • FiniteDifferenceStepSize

  • FiniteDifferenceType

  • FunctionTolerance

  • MaxFunctionEvaluations

  • MaxIterations

  • SpecifyObjectiveGradient

  • StepTolerance

  • TypicalX

• 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('fsolve','Algorithm','levenberg-marquardt');
  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.

• Normalmente, si especifica una opción no compatible, dicha opción se ignora silenciosamente durante la generación de código. No obstante, si especifica una función de gráfica o una función de salida utilizando notación de puntos, la generación de código puede emitir un error. Para una mayor fiabilidad, especifique únicamente opciones compatibles.

• Dado que las funciones de salida y las funciones de gráfica no son compatibles, los solvers no devuelven el indicador de salida –1.

Para ver un ejemplo, consulte Generar código para fsolve.

Soporte paralelo automático

Acelere código mediante la ejecución automática de cálculo paralelo mediante Parallel Computing Toolbox™.

Para ejecutar en paralelo, establezca la opción 'UseParallel' en true.

options = optimoptions('solvername','UseParallel',true)

Para obtener más información, consulte Usar la computación paralela en Optimization Toolbox.

Historial de versiones

Introducido antes de R2006a

R2023b: JacobianMultiplyFcn acepta cualquier tipo de datos

La sintaxis para la opción JacobianMultiplyFcn es

W = jmfun(Jinfo, Y, flag)

Los datos Jinfo, que MATLAB pasa a la función jmfun, ahora pueden ser de cualquier tipo. Por ejemplo, ahora puede hacer que Jinfo sea una estructura. En versiones anteriores, Jinfo tenía que ser un arreglo doble estándar.

Los datos Jinfo son la segunda salida de la función objetivo:

[F,Jinfo] = myfun(x)

R2023b: La opción CheckGradients se eliminará

La opción CheckGradients se eliminará en una versión futura. Para comprobar las primeras derivadas de funciones objetivo o funciones de restricción no lineales, utilice la función checkGradients.

Consulte también

fzero | lsqcurvefit | lsqnonlin | optimoptions | Optimize

Temas

• Resolver un sistema no lineal, sin y con matrices jacobianas
• Large Sparse System of Nonlinear Equations with Jacobian
• Large System of Nonlinear Equations with Jacobian Sparsity Pattern
• Sistemas no lineales con restricciones
• Configuración de problema de optimización basada en solvers
• Algoritmos de resolución de ecuaciones