You are on page 1of 27

UNIVERSIDAD DE GUAYAQUIL

FACULTAD DE INGENIERÍA QUÍMICA


CARRERA DE INGENIERÍA QUÍMICA

SIMULACIÓN DE PROCESOS II

TALLER #3
METODO DE RUNGE KUTTA
2DO PARCIAL

ESTUDIANTE:
SARA VERA HERNÁNDEZ

DOCENTE: ING. GONZALO VILLA

CURSO:
7MO SEMESTRE PARALELO “7-1”

FECHA DE REALIZACION: 12 DE ENERO DEL 2018


FECHA DE ENTREGA: 16 DE ENERO DEL 2018
INTRODUCCION
Los métodos de Runge-Kutta (RK) son un conjunto de métodos iterativos
(implícitos y explícitos) para la aproximación de soluciones de ecuaciones diferenciales
ordinarias, concretamente, del problema de valor inicial.

Sea y ′ ( t ) = f ( t , y ( t ) )

En análisis numérico, los métodos de Runge-Kutta son un conjunto de métodos


genéricos iterativos, explícitos e implícitos, de resolución numérica de ecuaciones
diferenciales. Este conjunto de métodos fue inicialmente desarrollado alrededor del año
1900 por los matemáticos C. Runge y M. W. Kutta.

La positiva es la llamada unidad imaginaria. Esta notación fue utilizada, de esta manera
por primera vez por Leonard Euler en 1779 y abre el camino a una rama muy interesante
de las matemáticas: el análisis de variable compleja, el cual veremos en estas secciones
MARCO TEORICO
Método de Runge-Kutta.
En esta sección nos limitamos a describir uno de los métodos de tipo Runge-Kutta más
utilizados en la práctica y cuyo orden de convergencia es 4 (lo que equivaldría a utilizar
un método basado en el desarrollo de Taylor hasta h4). Este método suele
denominarse método de Runge-Kutta clásico.
El método se describe como sigue:

donde las cantidades Ki se calculan de forma sucesiva como sigue:

Ejemplo
Se considera el problema de Cauchy o de valores iniciales:

Utilizamos el método de Runge-Kutta con paso h = 0.2 e intervalo de definición de la


solución el
[0, 1]. Comparamos con la solución exacta, y(x) = ex3
3.
Solución
La tabla de valores para este problema usando el método dado en el ejerciocio es la
siguiente:
Puede observarse la mayor precisión que este método consigue aun siendo, el paso
usado, el doble que el usado en el Ejemplo con paso h=0.1.
Los métodos de Taylor tienen la propiedad de un error local de truncamiento de orden
superior, pero la desventaja de requerir el cálculo y la evaluación de las derivadas de f(t,
y). Esto resulta algo lento y complicado, en la mayoría de los problemas, razón por la
cual, en la práctica casi no se utilizan. El método de Euler, lamentablemente requiere de
un paso muy pequeño para una precisión razonable.
Los métodos de Runge kutta tienen el error local de truncamiento del mismo orden que
los métodos de Taylor, pero prescinden del cálculo y evaluación de las derivadas de la
función f(t, y).
Se presenta de nuevo el problema de valor inicial cuya solución se intenta aproximar:

Como en los métodos anteriores, se determina primero la malla {t0, t1, ... , tN} de paso
h, donde t0 = a y tN = b. En estos puntos es donde se va a obtener la aproximación de
la solución.

En esencia, los métodos de Runge-Kutta son generalizaciones de la fórmula básica de


Euler yi+1 = yi + h f(ti, yi) en los que el valor de la función f se reemplaza por un promedio
ponderado de valores de f en el intervalo ti ≤ t ≤ ti+1, es decir,

En esta expresión las ponderaciones wi, i = 1, ..., m son constantes para las que en
general se pide que su suma sea igual a 1, es decir, w1 + w2 + ... + wm = 1, y cada kj es la
función f evaluada en un punto seleccionado (t, y) para el cual t i ≤ t ≤ ti+1. Se mostrará
que los kj se definen en forma recursiva.
Se define como orden del método al número m, es decir, a la cantidad de términos
que se usan en el promedio ponderado.

Runge-Kutta de primer orden

Si m = 1, entonces se toma w1 = 1 y la fórmula (2) resulta

(3)

Igualando esta fórmula al desarrollo de Taylor de orden 1 de la función y(t), alrededor


del punto ti, y calculado en el punto ti+1:

(4)

y teniendo en cuenta que yi @ y(ti), resulta k1= f(ti, yi), obteniendo así la fórmula de
Euler yi+1 = yi + h f(ti, yi). Por lo tanto, se dice también que el método de Euler es un
método de Runge Kutta de primer orden.

Runge-Kutta de segundo orden

Ahora se plantea, con m = 2, una fórmula del tipo:

(5)

donde

(6)

y las constantes a, b, a, b se deben determinar, de manera que la expresión (5) coincida


con el desarrollo de Taylor de y de orden más alto posible.

Para ello, utilizando un desarrollo de Taylor para funciones de dos variables, tenemos
que:

(7
)

donde el subíndice i indica que todas las derivadas están evaluadas en el punto (ti, yi).
Reemplazando k1 y teniendo en cuenta la expresión de k2, usando (7) tenemos que:

(8
)

agrupando los términos de (8) por las potencias de h, y reemplazando en la expresión


(5) el valor de k1 y k2, resulta

(9
)

Reacomodando términos en (9), resulta:

(1
0)

Por otro lado, se hace un desarrollo de Taylor de orden 3 de la función y(t), calculado
en el punto ti+1, obteniendo:

(11)

Aplicando regla de la cadena para las derivadas de f, se tiene:

(12
)

Comparando las expresiones (10) y (12), e igualando los coeficientes de h y h2, se tiene:

(13)
Sucede que se tienen cuatro incógnitas, pero tres ecuaciones, con lo que queda un
grado de libertad en la solución del sistema dado en (13). Se trata de usar este grado
de libertad para hacer que los coeficientes de h3 en las expresiones (10) y (12)
coincidan. Esto obviamente no se logra para cualquier f.

Hay muchas soluciones para el sistema (13), una de ellas es

(14)

obteniendo así la siguiente fórmula, del método de Runge Kutta de orden 2:

(15)

para i desde 0 hasta N-1, tomando un mallado {ti, i = 0, .., N}

Este método tiene un error local de O(h3), y global de O(h2).

Mejora entonces el método de Euler, por lo que se espera poder usar con este método
un paso mayor. El precio que debe pagarse en este caso, es el de evaluar dos veces la
función en cada iteración.

De la misma manera que se realizó arriba, se pueden derivar fórmulas de Runge-Kutta


de cualquier orden, pero estas deducciones resultan excesivamente complicadas. Una
de las más populares, y más utilizada por su alta precisión, es la de orden 4, que se
presenta a continuación.

Runge-Kutta de cuarto orden

Si ahora m = 4, se obtiene, con un desarrollo del tipo del anterior, la siguiente fórmula,
para i desde 0 hasta N-1:
(16)

Si bien con facilidad se pueden deducir otras fórmulas, el algoritmo expresado en (16)
se denomina método de Runge-Kutta de cuarto orden, o método clásico de Runge-
Kutta, abreviado como RK4. Este algoritmo es de uso extendido, y reconocido como
una valiosa herramienta de cálculo, por la buena aproximación que produce.

Esta fórmula tiene un error de truncamiento local de O(h 5), y un error global de
O(h4). De nuevo, el precio que se debe pagar por la mejora en el error, es una mayor
cantidad de evaluaciones de la función, resultando en un mayor tiempo de cálculo si
la función es complicada. Tiene la ventaja, sobre el método de Taylor de orden 4 (cuyo
error global es también O(h4), que no requiere el cálculo de las derivadas de f.
Implementación del método RK4

Se presenta a continuación el pseudocódigo del método RK4, para ser implementado


en cualquier lenguaje de programación, o software simbólico.

Ejemplo

Con el método RK4, obtener una aproximación del valor de y(1,5) para el siguiente
problema de valor inicial, tomando un paso h = 0,1.

El primer paso para resolver este problema es determinar la malla de puntos en donde
se va a obtener la solución.

Como en este caso h está dado, se tiene que N = (1,5 - 1)/0,1 = 5.

Por lo tanto, los puntos en donde se va a determinar la solución, dados por la fórmula
ti = 1 + 0,1 i, para i =1,2,3,4,5, son:

t1 = 1,1
t2 = 1,2
t3 = 1,3
t4 = 1,4
t5 = 1,5

Una vez establecida la malla del problema, tenemos, para i = 0:

Resulta entonces,

y aplicando sucesivamente la fórmula de RK4, para i desde 1 hasta 4, se obtienen los


datos que se muestran en la siguiente tabla, donde además se muestra el valor de la
solución exacta para cada punto de la malla.

Al analizar la tabla anterior y comparar los resultados obtenidos con el método RK4
con los valores reales, se ve por qué es tan difundido este método. En la próxima tabla
se comparan los métodos de Euler y Runge Kutta de orden 4 para el mismo problema.
La capacidad de usar un solucionador de pasos fijos no está incorporada en MATLAB 8.0
(R2012b).

Las funciones ordinarias de resolución de ecuaciones diferenciales provistas con


MATLAB emplean una variedad de métodos de paso variable. ODE23 se basa en el
método de integración Runge Kutta (2,3) y ODE45 se basa en el método de integración
Runge Kutta (4,5). ODE113 es un solucionador de PECE Adams-Bashforth-Moulton de
orden variable. Para obtener una lista completa de los distintos solucionadores y sus
métodos, consulte la documentación.

Los solucionadores de MATLAB ODE utilizan estos métodos dando un paso, estimando
el error en este paso, verificando si el valor es mayor o menor que la tolerancia, y
modificando el tamaño del paso en consecuencia. Estos métodos de integración no se
prestan a un tamaño de paso fijo. Usar un algoritmo que use un tamaño de paso fijo es
peligroso ya que puede perder puntos donde la frecuencia de la señal es mayor que la
frecuencia del solucionador. El uso de un paso variable garantiza que se use un tamaño
de paso grande para frecuencias bajas y un paso pequeño para frecuencias altas. Los
solucionadores de ODE dentro de MATLAB están optimizados para un paso variable, se
ejecutan más rápido con un tamaño de paso variable y, claramente, los resultados son
más precisos.

Ahora hay solucionadores de pasos de tiempo fijos disponibles:

ODE1 - Un método de Euler de primer orden

ODE2: un método de Euler de segundo orden

ODE3 - Un método de Runge-Kutta de tercer orden

ODE4: un método de Runge-Kutta de cuarto orden

ODE5 - Un método de Runge-Kutta de quinto orden

ODETest
Estos están incluidos en el archivo zip adjunto. Después de guardar los archivos
en una carpeta ubicada en la ruta MATLAB, estos solucionadores se pueden
usar con la siguiente sintaxis:

y = ode4 (odefun, tspan, y0);

La integración procede por pasos, llevados a los valores especificados en tspan. Los
valores de tiempo deben estar en orden, ya sea aumentando o disminuyendo. Tenga en
cuenta que el tamaño del paso (la distancia entre elementos consecutivos de tspan) no
tiene que ser uniforme. Si el tamaño del paso es uniforme, es posible que desee utilizar
LINSPACE.

Por ejemplo,

tspan = linspace (t0, tf, nsteps); % t0 = 0; tf = 10, nsteps = 100;

Dado que estos archivos no se envían con MATLAB, estos solucionadores no son
compatibles oficialmente.

Péndulo clásico: Algunas cuestiones relacionadas con el algoritmo

Este ejemplo muestra cómo la elección del algoritmo de estimación puede afectar los
resultados de una estimación del modelo de caja gris no lineal. Utilizamos datos
producidos por un sistema de péndulo no lineal, que se muestra esquemáticamente en
la figura 1. En particular, mostramos cómo la opción del solver de ecuación diferencial
repercute en los resultados.

Figura 1: Vista esquemática de un péndulo clásico.

Datos de salida
Comenzamos nuestro recorrido modelado por la carga de los datos de salida
(datos de series de tiempo). Los datos contienen una salida, y, que es la posición
angular del péndulo [rad]. El ángulo es cero cuando el péndulo está apuntando
hacia abajo, y aumenta hacia la izquierda. Hay 1001 muestras (simuladas) de puntos de
datos y el tiempo de la muestra es de 0,1 segundos. El péndulo se ve afectado por una
fuerza de gravedad constante, pero ninguna otra fuerza exógena afecta el movimiento del
péndulo. Para investigar esta situación, creamos un objeto IDDATA:

load(fullfile(matlabroot, 'toolbox', 'ident', 'iddemos',


'data', 'pendulumdata'));
z = iddata(y, [], 0.1, 'Name', 'Pendulum');
z.OutputName = 'Pendulum position';
z.OutputUnit = 'rad';
z.Tstart = 0;
z.TimeUnit = 's';

En una ventana de diagrama se muestra la posición angular del péndulo (la salida).

figure('Name', [z.Name ': output data']);


plot(z);

Figura 2: Posición angular del péndulo (salida).

Modelado de péndulo

El siguiente paso es especificar una estructura modelo para el sistema de péndulo. La


dinámica de la misma ha sido estudiada en numerosos libros y artículos y se entiende
bien. Si elegimos x1(t) posición angular [rad] como x2(t) como la velocidad angular
[rad/s] del péndulo, es bastante sencillo configurar una estructura de espacio de estado de
los siguientes tipos:

d/dt x1(t) = x2(t)


d/dt x2(t) = -(g/l)*sin(x1(t)) - (b/(m*l^2))*x2(t)
y(t) = x1(t)

tener parámetros (o constantes)

g - the gravity constant [m/s^2]


l - the length of the rod of the pendulum [m]
b - viscous friction coefficient [Nms/rad]
m - the mass of the bob of the pendulum [kg]

Entramos a esta información en el pendulum_m.m archivo MATLAB, con el contenido


siguiente:

function [dx, y] = pendulum_m(t, x, u, g, l, b, m,


varargin)
%PENDULUM_M A pendulum system.
% Output equation.
y = x(1); % Angular
position.
% State equations.
dx = [x(2); ... % Angular
position.
-(g/l)*sin(x(1))-b/(m*l^2)*x(2) ... % Angular
velocity.
];

El siguiente paso es crear un objeto genérico IDNLGREY para describir el péndulo.


También entramos en información sobre los nombres y las unidades de las entradas, los
Estados, salidas y parámetros. Debido a la realidad física los parámetros del modelo deben
ser positivos y esto se impone al establecer la propiedad 'Mínimo' de todos los parámetros
para el valor positivo más pequeño reconocible en MATLAB®, eps(0).

Rendimiento de tres modelos de péndulo inicial

Antes de calcular cualquier parámetro se simula el sistema con los valores de parámetro
adivinado. Hacemos esto para tres de los solvers disponibles, Euler hacia adelante con la
longitud de paso fijo (ode1), Runge-Kutta 23 con longitud de paso adaptativo (ode23) y
Runge-Kutta 45 con longitud de paso adaptativo (ode45). Los resultados obtenidos al usar
estos tres problemas se muestran en una ventana de diagrama.
% A. Model computed with first-order Euler forward ODE
solver.
nlgref = nlgr;
nlgref.SimulationOptions.Solver = 'ode1'; % Euler
forward.
nlgref.SimulationOptions.FixedStep = z.Ts*0.1; % Step
size.

% B. Model computed with adaptive Runge-Kutta 23 ODE solver.


nlgrrk23 = nlgr;
nlgrrk23.SimulationOptions.Solver = 'ode23'; % Runge-
Kutta 23.

% C. Model computed with adaptive Runge-Kutta 45 ODE solver.


nlgrrk45 = nlgr;
nlgrrk45.SimulationOptions.Solver = 'ode45'; % Runge-
Kutta 45.

compare(z, nlgref, nlgrrk23, nlgrrk45, 1, ...


compareOptions('InitialCondition', 'model'));

Figura 3: Comparación entre la salida real y las salidas simuladas de los tres modelos de
péndulo inicial.

Como puede verse, el resultado con el método delantero de Euler (con una cuadrícula más
fina de lo que se utiliza por defecto) difiere significativamente de los resultados obtenidos
con el Runge-Kutta solvers. En este caso, resulta que el solucionador de Euler hacia
adelante produce un resultado bastante bueno (en términos de ajuste del modelo),
mientras que los resultados obtenidos con el Runge-Kutta solvers son un poco limitadas.
Sin embargo, esto es algo engañoso, como será evidente más adelante, porque el valor
inicial de b, el coeficiente de fricción viscosa, es dos veces tan grande como en realidad.

Estimación de parámetros
La constante gravitacional, g, la longitud de la varilla, l y la masa de la sacudida,
m, fácilmente pueden ser medidos o tomados de una tabla sin estimación. Sin
embargo, esto normalmente no es el caso con los coeficientes de fricción, que a
menudo debe ser estimado. Por lo tanto fijamos los tres parámetros anteriores a g = 9.81,
l = 1 y m = 1 y considerar sólo b como parámetro libre:

nlgref = setpar(nlgref, 'Fixed', {true true false true});


nlgrrk23 = setpar(nlgrrk23, 'Fixed', {true true false
true});
nlgrrk45 = setpar(nlgrrk45, 'Fixed', {true true false
true});

A continuación calculamos b utilizando las tres solvers de ecuación diferencial.


Comenzamos con la estructura del modelo base delantero de Euler.

opt = nlgreyestOptions('Display', 'on');


tef = clock;
nlgref = nlgreyest(z, nlgref, opt); % Perform parameter
estimation.
tef = etime(clock, tef);

Luego continuamos con el modelo basado en el Runge-Kutta 23 solver (ode23).

trk23 = clock;
nlgrrk23 = nlgreyest(z, nlgrrk23, opt); % Perform parameter
estimation.
trk23 = etime(clock, trk23);

Finalmente utilizamos el Runge-Kutta 45 solver (ode45).

trk45 = clock;
nlgrrk45 = nlgreyest(z, nlgrrk45, opt); % Perform parameter
estimation.
trk45 = etime(clock, trk45);

Rendimiento de tres modelos de péndulo Estimado

A continuación se resumen los resultados al usar estos tres problemas. El verdadero valor
de b es 0,1, que se obtiene con ode45. ode23 devuelve un valor bastante cercano a 0,1,
mientras ode1 devuelve un valor absolutamente una distancia de 0.1.

disp(' Estimation time Estimated b value');


fprintf(' ode1 : %3.1f %1.3f\n', tef,
nlgref.Parameters(3).Value);
fprintf(' ode23: %3.1f %1.3f\n', trk23,
nlgrrk23.Parameters(3).Value);
fprintf(' ode45: %3.1f %1.3f\n', trk45,
nlgrrk45.Parameters(3).Value);
Estimation time Estimated b value
ode1 : 12.1 0.194
ode23: 7.3 0.093
ode45: 11.0 0.100

Sin embargo, esto no significa que las salidas simuladas difieren que mucho de
la salida real, porque los errores producción por los solvers de ecuación diferencial
diferentes son típicamente representaron en el procedimiento de estimación. Esto es un
hecho que fácilmente puede verse mediante la simulación de los tres modelos de péndulo
estimado.

compare(z, nlgref, nlgrrk23, nlgrrk45, 1, ...


compareOptions('InitialCondition', 'model'));

Figura 4: Comparación entre la verdadera salida y las salidas simuladas de los tres
modelos de péndulo estimado.

Como era de esperar teniendo en cuenta esta cifra, el Error de predicción Final (FPE),
valores de criterio de estos modelos son también bastante cerca entre sí:

fpe(nlgref, nlgrrk23, nlgrrk45);


1.0e-03 *

0.1609 0.1078 0.1056


EJERCICIO EN CLASES
Integración numérica de ecuaciones diferenciales
Solución para una ecuación diferencial esa dada por f(x), aproximadamente a la
solución del problema del valor inicial
𝑦 ′ = 𝑓(𝑡, 𝑥) 𝑐𝑜𝑛 𝑦0 = 𝑦(𝑎)
En el intervalo (a,b) mediante el método de rung-kutta de segundo orden
Resolver la siguiente ecuación:
𝑑𝑦 𝑦+1
= 𝑦(0) = 1
𝑑𝑥 𝑦−1
Solucion ´
Primero almacenamos la función como un archivo ODEF1
Luego creamos una función donde desarrollamos el metodo de Runge Kutta y lo
guardamos como RK2.
Luego en un script o ventamos de comando ingresamos [x,y] = RK2(@ODEF1,0,0.4,1,4)
TALLER 3

function [ DYDX ] = ODEF1( X,Y )


DYDX =(Y+1) / (X-1)

return;
%%Aproximacion a la solucion del problema del valor inicial
%y´= f(t,x) con y0=y(a) el intervalo [a, b],
%mediante el metodo de Runge-Kutta de segundo orden
%---------------------------------------------%

function [t, Y] = RK2(F, a, b, Y0, N )


%---------------------------------------------%
%Sintaxis
%[t, Y]=RK2(F, a, b, Y0, N)
%Entrada
% - F es la funcion almacenadfa como un archivo F.m
% - a y b son los extremos del intervalo
% - Y0 es la condicion inicial Y0=Y(a)
% - N es el numero de paso
%Salida
% - t es el vector de las abscisas o variable independinte
% - Y es el vector de las ordenadas o varible dependiente
%------------------------------------------------------%
H=(b - a)/N;
t=zeros(1, N+1);
t=[a: H: b]
Y(1)= Y0;
for J=1:N
K1 = H * feval (F, t(J), Y(J));
K2 = H * feval (F, t(J) + H, Y(J) + K1);
Y(J +1)= Y(J) + 0.5 * (K1 + K2);
end
t=t';
Y=Y';
end

clear,clc
[x,y]=RK2(@ODEF1, 0, 0.4, 1, 4)
COMANDOS

FEVAL

Sintaxis

[y1,...,yN] = feval(fun,x1,...,xM)

Descripción

[ y1,...,yN ] = feval( fun , x1,...,xM ) evalúa una función usando su nombre o su


manejador, y utilizando los argumentos de entrada x1,...,xM .

La función feval sigue las mismas reglas de alcance y precedencia que llamar
directamente a un identificador de función. Para obtener más información.

Ejemplos

Evaluar función con nombre de función como vector de caracteres

Redondee el valor de pi al entero más cercano utilizando el nombre de la función.

diversión = 'ronda' ;
x1 = pi;
y = feval (diversión, x1)
y=3
Redondee el valor de pi a dos dígitos a la derecha del punto decimal.

x2 = 2;
y = feval (diversión, x1, x2)
y = 3.1400

Argumentos de entrada

fun - Función para evaluar

nombre de la función | manejar la función

Función para evaluar, especificada como nombre de función o manejador de una


función. La función acepta M argumentos de entrada, y devuelve N argumentos de
salida. Para especificar fun como nombre de función, no incluya información de ruta.

Invocar feval con un identificador de función equivale a invocar el identificador de


función directamente.

Ejemplo: fun = 'cos'

Ejemplo: fun = @sin

x1,...,xM - Entradas a la función evaluada

depende de la función

Entradas a la función evaluada. Los tipos de entradas dependen de la función, fun .

Argumentos de salida

y1,...,yN - Salidas de la función evaluada

depende de la función

Salidas de la función evaluada. Los tipos de salidas dependen de la función, fun .

Consejos

 Si tiene un identificador de función, no es necesario utilizar feval porque puede


invocar directamente el identificador de función. Los resultados de las siguientes
afirmaciones son equivalentes.
 fh = @eig;
 [V, D] = fh (A)

[V, D] = feval (@ eig, A)
 Para evaluar una función anidada o local utilizando feval , use un
identificador de función en lugar del nombre de la función.

funciones

Información sobre el manejo de la función

Sintaxis

s = functions(fh)

Descripción

s = functions( fh ) devuelve información sobre un manejador de función. Esta


información incluye el nombre de la función, el tipo y el nombre del archivo.

Utilice la functions funciones solo para fines de consulta y depuración.

Nota

No use las functions programáticamente porque su comportamiento podría cambiar


en las versiones posteriores de MATLAB ® .

Ejemplos

Mostrar información sobre la función nombrada Manejar

Crea un identificador de función y muestra su información.

fh = @cos;
s = funciones (fh)
s = struct con campos:
función: 'cos'
tipo: 'simple'
archivo: ''

Mostrar información sobre la función anónima Handle

Crear un identificador de función para una función anónima. Muestra su información y


valores de las variables requeridas.

Cree un control para la función x 2 + y , e invoque la función usando el mango.

y = 7;
fh = @ (x) x. ^ 2 + y;
z = fh (2)
z =

11

Muestra información sobre el control de función.

s = funciones (fh)
s =

función: '@ (x) x. ^ 2 + y'


tipo: 'anónimo'
archivo: ''
espacio de trabajo: {[1x1 struct]}
within_file_path: '__base_function'

El controlador de función contiene el valor requerido de y .

en el espacio de trabajo {1}


ans =

y: 7

Mostrar información sobre el identificador de función anidada y local

Cree una función que devuelva identificadores a funciones locales y anidadas. Muestra
su información.

Cree la siguiente función en un archivo, functionsExample.m , en su carpeta de


trabajo. La función devuelve identificadores a una función anidada y local.

función [hNest, hLocal] = functionsExample (v)

hNest = @nestFunction;
hLocal = @localFunction;

función y = nestFunction (x)


y = x + v;
fin

fin

función y = función local (z)


y = z + 1;
fin

Invoca la función.

[hNest, hLocal] = functionsExample (13)


hNest =
@ functionsExample / nestFunction

hLocal =

@localFunction

Muestra información sobre el manejador de la función anidada.

s1 = funciones (hNest)
s1 =

función: 'functionsExample / nestFunction'


tipo: 'anidado'
archivo: 'C: \ work \ functionsExample.m'
espacio de trabajo: {[1x1 struct]}

Muestra información sobre el manejador de la función local.

s2 = funciones (hLocal)
s2 =

función: 'localFunction'
tipo: 'función de alcance'
archivo: 'C: \ work \ functionsExample.m'
parentage: {'localFunction' 'functionsExample'}

Argumentos de entrada

fh - fh para consultar manejar la función

Manejar para consulta, especificado como un manejador de función.

Argumentos de salida

s - Información sobre el manejo de la función estructura

Información sobre un manejador de función, devuelto como una estructura. La estructura


contiene los siguientes campos.

Nombre del
campo Descripción
campo
Nombre de la función. Si la función asociada con el identificador es una
function función anidada, el nombre de la función toma la forma
main_function / nested_function .
Tipo de función Por ejemplo, 'simple' , 'nested' ,
type
'scopedfunction' o 'anonymous' .
Nombre del
campo Descripción
campo
Ruta completa a la función con la extensión de archivo.

 Si la función es una función local o anidada, entonces el file es


la ruta completa a la función principal.
 Si la función está incorporada en la función MATLAB o en una
file
función anónima, entonces el file es una matriz de caracteres
vacía ( '' ).
 Si carga un identificador de función guardada, entonces el file
es una matriz de caracteres vacía ( '' ).

La estructura tiene campos adicionales según el tipo de función asociada al identificador.


Por ejemplo, una función local tiene un campo de parentage , y una función anónima
tiene un campo de área de workspace . Use la información en s para propósitos de
consulta y depuración.

CONCLUSIONES

En base a esto que podemos concluir que los tres modelos son capaces de captar la
dinámica del péndulo, pero el modelo basado en adelante Euler refleja que subyacente
física bastante mal. La única manera de aumentar su rendimiento de "física" es disminuir
la longitud de paso de los problemas, pero esto también significa que aumenta
significativamente el tiempo de solución. Nuestros experimentos indican que el Runge-
Kutta 45 solver es el mejor solucionador para problemas no rígida al tomar velocidad
computacional en cuenta y precisión.

El Runge-Kutta 45 (ode45) solver a menudo devuelve resultados de alta calidad


relativamente rápido y por lo tanto, es elegido como el solver de ecuación diferencial por
defecto en IDNLGREY. Escribir "ayudar a idnlgrey. SimulationOptions"ofrece algunos
detalles más sobre las soluciones disponibles y escribir "help nlgreyestOptions"
proporciona información detallada sobre las diferentes opciones de valoración que
pueden ser utilizadas para IDNLGREY de modelado.