UNIVERSIDAD DE GUAYAQUIL

FACULTAD DE INGENIERÍA QUÍMICA

CARRERA DE INGENIERÍA QUÍMICA

SIMULACION
DE PROCESOS INDUSTRIALES II
(701)

TALLER # 6
METODO DE RUNGE KUTTA Y METODO DE EULER

NOMBRE DEL ESTUDIANTE:

 ARIAS FUENTES GEORGE

NOMBRE DEL PROFESOR

ING. GONZALO VILLA

CURSO: 7-1
FECHA DE ENTREGA:
LUNES 14 DE ENERO DEL 2019

CI. PERIODO 2018-2019

 METODO DE RUNGE KUTTA
MARCO TEORICO

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

Métodos 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 {t 0, 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 t i ≤ 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, w 1 + w2 + ... + wm
= 1, y cada kj es la función f evaluada en un punto seleccionado (t, y) para el
cual ti ≤ 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 h 3 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 tercer orden

Se trata de la misma idea pero integrando por el Método de Simpson,

entonces:

Donde son estimaciones, puesto que

no son conocidos.

La estimación de se hace por el método de Euler:

mientras que la estimación se pueden considerar varias opciones,

por ejemplo:

es decir el Método de Euler de nuevo, o por ejemplo:

Que consiste en variar el Método de Euler tomando la pendiente de la recta tangente
en el punto medio en vez de la tangente en el punto propiamente dicha. Finalmente, lo
más usual es tomar una combinación de las dos opciones

Podemos entonces resumir el Método de Runge-Kutta de tercer orden en la forma:

Finalmente, añadir que el error local en el Método de tercer orden es proporcional a

4 3
h y en consecuencia el global lo es a h

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.

EJERCICIO RESUELTO EN CLASES

Para realizar las ecuaciones diferenciales por el Método de Runge Kutta de
cuatro parámetros se elaboró la función odelgil4 de paso de integración fijo:
FUNCION UTILIZANDO ODEGIL4 PARA EDO

%---script para integraciones de EDO por Runge Kutta, de 4 parametros----

--

function [t,y]=odegil4(f,x,y0,h)
%[t,y]=odegil4(f,x,y0,h),resuelve ecuaciones y'=f(t,y),
%x vector en linea de la variabe independiente,
%yo vector en linea de las condiciones iniciales,
%h paso de integración
%---------------------------------------------------------------------
-----
x=x';t=[];t(1)=x(1);y=y0;
N=(x(length(x))-x(1))/h; Ne=length(y0);
for I=1:N
T=t(I);
Y=y(I,:);
for J=1:Ne
p=h*feval(f,T,Y');
q=h*feval(f,T+h/2,Y'+p/2);
r=h*feval(f,T+h/2,Y'+q/2);
s=h*feval(f,T+h,Y'+r);
end
t(I+1)=t(1)+h*I;
Inc=(p+2*q+2*r+s)/6;
y(I+1,:)=y(I,:)+Inc';
end
y=spline(t,y',x);
y=[reshape(y,Ne,length(x))]';
t=x;
end
En Matlab:

Este no posee resultado ya que necesitamos un script para llamar a esta función
con la integración de los valores encontrados en el primer script, para luego
obtener un grafica como resultado final.

La aplicación se materializa en el siguiente ejemplo que se evalúa de 2t, 3t2,4t3

y cos(x), cuyas soluciones son t2, t3,t4 y suma (x)
Definir, función: ecudif.m
function [dy] = ecudif(t,y)
%evalue el modo de demostracion la integracion de 2t, 3t^2, 4t^3
%y cos(x), cuyas soluciones son:t^2, t^3, t^4 y seno(t).
dy(1)=2*t;
dy(2)=3*t.^2;
dy(3)=4*t.^3;
dy(4)=cos(t);
dy=[dy(1);dy(2);dy(3);dy(4)]
%-------------------------------------
end
En Matlab:

Para resolver el problema se lanza con las siguientes instrucciones:

%-----------scrip para integracion de funciones y su representacion grafica

clear,clc
%-----------------------EcuadifP.m--------------------------
x=[0:5] %valores de presentacion de resultados
y0=[0 0 0 0]; %condiciones iniciales
h=0.01; %paso de integracion.
tic %comienzo de temporizacion.
[t,y]=odegil4('ecudif',x,y0,h); %llamada a la integracion
toc %final de la temporizacion.
%------------------------------------------

En Matlab:

RESULTADO:
 ANALISIS DEL SCRIP
 Scrip con nombre de odegil4:

Análisis: Nos muestra el mensaje de script para la integración de EDO por

medio de 4 parámetros.

Análisis: me estable una función cuyas variables de entrada so f, x, y0, h. cuyo

nombre de la función es odegil4. Aquí se declara la función con el nombre de
odegil4 que acepta como entrada a las variables de so f, x, y0, h.

Análisis: Nos muestra un mensaje diciendo con indicaciones para resolver las
siguientes ecuaciones EDO.

Análisis: Nos muestra un mensaje con indicaciones de cuáles son las

variables independientes.

Análisis: Nos muestra un mensaje diciendo que y0 es un vector que se

encuentra en las condiciones iniciales.
Análisis: Nos muestra el mensaje de cual va a ser el paso de integración.

Análisis: Línea de espacio

Análisis: Aquí se define cada vector con sus respectivas variables.

 En donde x=x' es la matriz transpuesta.
 En el vector t se eliminan los elementos mediante la asignación del
espacio.
 En función t (1)=x (1) me expresa que el primer elemento del vector t va
a ser igual al primer elemento del vector x.
 Aquí expresa que la variable de y va a ser igual a la variable y0.

Análisis: En estas líneas se define la longitud de las dimensiones de la matriz

más grande así como el tamaño del vector.

Análisis: En estas líneas se ejecutan un grupo de instrucciones para repetir el

número especificado de veces para la variable I, esta es una de las
instrucciones especificadas para la función correspondiente.

Análisis: Defino que en la fila I de la matriz Y

Análisis: For nos permite ejecutar nuevas instrucciones un número

especificado de veces de la variable J.

Análisis: En esta línea se evalúa la función utilizando las variables de entrada

las cuales son (f,T,Y').
Análisis: El código feval nos permite evaluar la función utilizando las variables
de entrada.

Análisis: Nos permite dar por finalizado las instrucciones establecidas para la
nueva función permitiéndome cerrar uno de los ciclos for.

Análisis: En la presente ecuación la variable t funciona como almacenamiento

ya que por cada ciclo va a ir almacenando el resultado en la operación.

Análisis: En esta línea podemos observar la base de datos almacenados.

Análisis: Aquí la la variable y funciona una variable de almacenamiento por lo

que cada ciclo que finaliza se acumula en la operación.

Análisis: En esta línea da por finalizado los dos ciclos de instrucciones

específicas.

Análisis: Este código permite devolver un vector de valor interpolado

correspondiente al punto de consulta x. los valores de y se determinan
interpolando las variables de entrada t, y’.

Análisis: En esta línea podemos reformular el vector (y) utilizando el vector de

tamaño Ne.

Análisis: En esta línea queda definido que el vector t sera equitativamente igual
al vector x.

%------------------------------------------------------
  Scrip con nombre de ecudif.m:

Análisis: Aquí se declara la función con el nombre de ecudifm, que acepta

como entrada a las variables de t, y.

Análisis: Nos indica en comentario las directrices del problema planteado.

Análisis: Se describe la ecuación de la variable dy(1) donde se determina su

respectivo valor.

Análisis: Se describe la ecuación de la variable dy(2) donde se determina su

respectivo valor.

Análisis: Se describe la ecuación de la variable dy(3) donde se determina su

respectivo valor.

Análisis: Se describe la ecuación de la variable dy(4) donde se determina su

respectivo valor

Análisis: En esta línea se demuestra la integración todas las variables dy

mencionadas en líneas anteriores.

Análisis: Termina el bloque del código.

  Scrip con nombre de ecudifP.m:

Análisis: Nos indica en comentario las directrices del problema planteado.

Análisis: Elimina los elementos que se encuentren en el espacio de trabajo,

liberando la memoria del sistema. El código clc me permite borrar ventana de
comandos.

Análisis: Comentario con nombre en el que se guardo el scrip.

Análisis: Se establece un ciclo para la respectiva variable x que va desde 0

hasta 5. Con un comentario que indica los valores de presentación de
resultados.

Análisis: Establece el vector y0 con un comentario que indica que son las
condiciones iniciales.

Análisis: Asignamos la condición especifica al vector h con un comentario que

indica paso de integración.

Análisis: Aquí medimos el rendimiento con el cronometro iniciado por el

comando tic.

Análisis: En esta línea llamamos a la ecuación ecudif manteniendo a las dos

variables de salida t e y. también evalúa las variables de entrada.

Análisis: Aquí termina la medición del rendimiento. Con un comentario que

indica el final de la temporización.
 METODO DE EULER
MARCO TEORICO
El método de Euler consiste en encontrar iterativamente la solución de una ecuación
diferencial de primer orden y valores iniciales conocidos para un rango de valores.
Partiendo de un valor inicial x0 y avanzando con un paso h, se pueden obtener los
valores de la solución de la siguiente manera:

Yk+1 = Yk + h · f(xk, Yk)

Donde Y es solución de la ecuación diferencial y f es la ecuación diferencial en función
de las variables independientes
EJEMPLO EN MATLAB
Ejemplo2.2:

Resolver el problema de valores iniciales utilizando Matlab con el método de Euler

y 0 = t − y y(0) = 1 t ∈ [0, 1]

Solución:

1. Resolver el problema anterior con N = 16;

 function fxy=ejemplo2_2(t,y)
 fxy=t-y; f=’ejemplo2_2’
 [t,y]=euler(f,0,1,1,16)
 function [t,y]=euler(f,a,b,y0,N)
 h=(b-a)/N; % longitud del paso
 t(1)=a;
 y(1)=y0;
 for n=1:N %
 t(n+1)=t(n)+h;
 % Llamadas a f(t,y)=dy/dt
 y(n+1)=y(n)+h*feval(f,t(n),y(n));
 end
 t=t’; y=y’;
 plot(t,y)
 xlabel([’Metodo de Euler con N=’, num2str(N),’ psos’])
 EJERCICIO RESUELTO EN CLASES

Integración numérica de ecuaciones diferenciales

Aproximación a la solución del problema del valor inicial
𝑦 ′ = 𝑓 (𝑡, 𝑦0) = 𝑦(𝑎)
En el intervalo (a,b) mediante el método de euler
Resolver la siguiente ecuación:

Resolver la siguiente ecuación mediante el método de Euler:

𝑑𝑦 𝑦 + 1
= 𝑦(0) = 1;
𝑑𝑥 𝑥 − 1
Primero almacenamos la función como un archivo por ejemplo ODEF1.m

Luego creamos otra función donde desarrollamos el método de Euler y lo

guardamos como EULER.m
RESULTADO DEL METODO:
 ANALISIS DEL SCRIP

 Scrip con nombre de ODEF1:

Análisis: Se declara la función llamada ODEF1. Tiene las variables de entrada

de X o Y, también devuelve la variable de salida DYDX.

Análisis: Se describe la ecuación correspondiente para la variable DYDX.

Análisis: En esta línea return devuelve el control a la función de invocación

antes de que llegue a final de la función.

 Scrip con nombre de EULER:

Análisis: En estas líneas establecemos comentarios dando las pautas para la

resolución del problema.

Análisis: Se declara la función EULER, que recibe como valor de entrada a las
variables (F, a, b, Y0, N) y determina las variables de salidas t ,y.

Análisis: En estas líneas establecemos comentarios dando las pautas para la

resolución de la ecuación.
Análisis: Mediante la siguiente ecuación me ayuda a encontrar el incremento
restando los extremos de intervalos y dividiéndolos para el número de pasos.

Análisis: Aquí se determina el vector independiente y el comando zeros me

ayuda a devolver una matriz por 1, N+1 de ceros al vector t o variable
independiente.

Análisis: El vector dependiente y el comando zeros me ayuda a devolver una

matriz por 1, N+1 de ceros al vector y o variable dependiente.

Análisis: Establecemos el vector t con un incremento en los intervalos de los

extremos.

Análisis: Indicamos que el primer valor del vector y va a ser y0.

Análisis: Establecemos un ciclo de repetición para el valor de la variable J.

Análisis: En esta línea feval permite evaluar el ciclo que se inicio para la variable
J una vez que se encuentre el valor el ciclo se dará por finalizado.

Análisis: Indica el cierre del ciclo.

Análisis: esta línea me dice que los siguientes valores de la variable

independiente es igual a los valores de la integración de la misma variable.
Análisis: Indica el final de la función.

 El scrip con nombre de SALIDA_EULER.M:

Análisis: Elimina los elementos que se encuentren en el espacio de trabajo,

liberando la memoria del sistema. El código clc me permite borrar ventana de
comandos.

Análisis: Aquí se establece la ecuación y encontramos una solución para la

misma llamándome a la función ODEF1.

COMANDOS NUEVOS:
COMANDO TIC

Espera que el tiempo medido en la computadora sea uniforme, en unidades

estándar como segundos, y lo suficientemente preciso como para usarlo para
medir cálculos breves. ¿Qué limita la uniformidad y precisión de la medición de
tiempo en su computadora? Para responder a esta pregunta, primero debemos
entender qué hora es y cómo se mide en una computadora.
Cada repetición se llama tic. El número de tics por segundo o la frecuencia se
mide en hercios.
Sintaxis
tic
timerVal = tic
Descripción
ticinicia un cronómetro para medir el rendimiento. La función registra el tiempo
interno en la ejecución del ticcomando. Muestra el tiempo transcurrido con
la tocfunción.
timerVal = ticdevuelve el valor del temporizador interno en la ejecución
del ticcomando, de modo que puede registrar el tiempo para períodos de tiempo
simultáneos
COMANDO TOC
Leer el tiempo transcurrido desde el cronómetro
Imprime el tiempo transcurrido desde que tic se usó.

MATLAB incluye dos funciones tic y TOC. Si se llama a TIC antes de que se
programe algo, y se invoca TOC después, TOC imprimirá el tiempo de reloj de
pared transcurrido si su valor no se copia a una variable, o devolverá el valor del
tiempo de reloj de pared transcurrido a una variable.
Sintaxis
toc
elapsedTime = toc
toc(timerVal)
elapsedTime = toc(timerVal)
Descripción
Toc lee el tiempo transcurrido desde el temporizador de cronómetro iniciado por
el tic función. La función lee el tiempo interno en la ejecución del toc comando y
muestra el tiempo transcurrido desde la última llamada al tic función que no tuvo
salida, en segundos.
elapsedTime = toc devuelve el tiempo transcurrido en una variable.
toc(timerVal)muestra el tiempo transcurrido desde el tic comando
correspondiente a timerVal.
elapsedTime = toc(timerVal)devuelve el tiempo transcurrido desde el tic
comando correspondiente a timerVal.
 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
function una función anidada, el nombre de la función toma la forma
main_function / nested_function .
Tipo de función Por ejemplo, 'simple' , 'nested' , 'scopedfunction' o
type
'anonymous' .
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
file
una 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.

RETURN:

Produce que vuelva a realizar una función.

 Ejemplo:
1. En una carpeta de trabajo actual, produzca una función findSqrRootIndex,
para determinar el índice de la primera aparición de la raís cuadrada de
un valor dentro de una matriz. Si no se encuentra la raíz cuadrada, la
función devuelve Nan
function idx = findSqrRootIndex(target,arrayToSearch)
idx = NaN;
if target < 0
return
end

for idx = 1:length(arrayToSearch)

if arrayToSearch(idx) == sqrt(target)
return
end
end

2. En el símbolo del sistema, llame a la función.

A = [3 7 28 14 42 9 0];
b = 81;
findSqrRootIndex(b,A)
ans =
6

ZEROS (mathworks)

Crear matrices llenas de ceros.

 Síntaxis:
𝑋 = 𝑧𝑒𝑟𝑜𝑠 Devuelve el escalar 0.
𝑋 = 𝑧𝑒𝑟𝑜𝑠(𝑛) devuelve una “n” por “n” matriz de ceros.
𝑋 = 𝑧𝑒𝑟𝑜𝑠(𝑠𝑧1, . . . , 𝑠𝑧𝑁) devuelve un “sz1” por “szN” llenos de cero
donde sz1,...,szN indican el tamaño de cada dimensión. Por
ejemplo, zeros(2,3)devuelve una matriz de 2 por 3.
𝑋 = 𝑧𝑒𝑟𝑜𝑠(𝑠𝑧) Devuelve una matriz de ceros donde “sz” define el vector de
tamaño size(X). Por ejemplo, zeros([2 3])devuelve una matriz de 2 por 3.

 Ejemplos:
1. Crea una matriz de ceros de 4 por 4.
X = zeros (4)
X=
0000
0000
0000
0000

2. Cree una matriz de ceros que sea del mismo tamaño que una matriz
existente.
A = [1 4; 2 5; 3 6];
sz = length(A);
X = zeros (sz)
X=
00
00
00

RESHAPE
Cambiar la forma de matriz

Sintaxis
B = reshape(A,sz)
B = reshape(A,sz1,...,szN)
Descripción

B = reshape(A,sz) modifica la forma de A con el vector de tamaño, sz, para definir

size(B). Por ejemplo, reshape(A,[2,3]) modifica la forma de A en una matriz de 2 por
3. sz debe contener al menos 2 elementos, y prod(sz) debe ser igual a numel(A).

B = reshape(A,sz1,...,szN) modifica la forma de A en un sz1- por -... -por -szN matriz

donde sz1,...,szN indica el tamaño de cada dimensión. Puede especificar un tamaño
de la sola dimensión de [] que el tamaño de la dimensión se calcula automáticamente, tal
que el número de elementos de B coincide con el número de elementos en A. Por ejemplo,
si A es una matriz de 10 por 10, reshape(A,2,2,[]) remodela los 100 elementos de A
en una matriz de 2 por 2 por 25.

Ejemplos
Cambiar la forma de Vector a matriz

Cambiar la forma de un vector de 1 por 10 en una matriz de 5 por 2.

A = 1:10;
B = reshape(A,[5,2])
B = 5×2

1 6
2 7
3 8
4 9
5 10
Cambiar la forma de matriz para ha especificado el número de columnas

Cambiar la forma de una matriz cuadrada de 4 por 4 en una matriz que tiene 2 columnas.
Especificar [] para la primera dimensión hacerle reshape calcular automáticamente el
número adecuado de filas.

A = magic(4)
A = 4×4

16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1

B = reshape(A,[],2)
B = 8×2

16 3
5 10
9 6
4 15
2 13
11 8
7 12
14 1

El resultado es una matriz de 8 por 2, que mantiene el mismo número de elementos que
la matriz original. Los elementos de B también mantienen su orden columnwise de A.
Remodelar la matriz Multidimensional en la matriz

Cambiar la forma de una matriz de 3 por 2 por 3 de ceros en una matriz de 9-2.

A = zeros(3,2,3);
B = reshape(A,9,2)
B = 9×2

0 0
0 0
0 0
0 0
0 0
0 0
0 0
0 0
0 0

SPLINE

Interpolación de datos de spline cúbico

Sintaxis
s = spline(x,y,xq)
pp = spline(x,y)
Descripción

s = spline(x,y,xq) devuelve un vector de valores interpolados s correspondientes a

los puntos de consulta en xq. Los valores de s se determinan por interpolación de spline
cúbico de x e y.

pp = spline(x,y) devuelve un polinomio por trozos de la estructura para el uso por

ppval y el spline utilidad unmkpp.
Ejemplos
Interpolación spline de seno datos

Utilice spline para interpolar una curva

sinusoidal sobre puntos de la muestra
irregularmente espaciados.

x = [0 1 2.5 3.6 5 7 8.1 10];

y = sin(x);
xx = 0:.25:10;
yy = spline(x,y,xx);
plot(x,y,'o',xx,yy)

Interpolación spline de distribución con Endpoint especificado pendientes

Uso fija o interpolación de spline completo al

extremo de pistas son conocidos. Este ejemplo
aplica cero pistas en los puntos de final de la
interpolación.

x = -4:4;
y = [0 .15 1.12 2.36 2.36 1.46 .49 .06 0];
cs = spline(x,[0 y 0]);
xx = linspace(-4,4,101);
plot(x,y,'o',xx,ppval(cs,xx),'-');
CONCLUSIONES

Encontramos que las subrutinas soportadas muestran errores en el rango de 0.1 a 0.5%;
mientras que ode4 muestra un error máximo de menos de 10 ^ -7%, es decir, 10 ^ 6 veces
más pequeño. Estos resultados indican que ode4 debería ser probablemente la primera
subrutina de Runge-Kutta que se intenta resolver para ODE. 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. Los scripts adjuntos resuelven la Ecuación Diferencial
Ordinaria de Vector de Órbita de Dos Órganos usando una subrutina compatible con
MATLAB ode45, ode23 u ode23s y también usando una subrutina ode4 no soportada
simple (disponible en el archivo adjunto y en cualquier otro lugar en File Exchange).

REFERENCIAS
http://campus.usal.es/~mpg/Personales/PersonalMAGL/Docencia/MetNumTem
a4Teo(09-10).pdf
mathwoks. (s.f.). Recuperado el 15 de enero de 2018, de mathworks:
https://la.mathworks.com/help/matlab/ref/toc.html?searchHighlight=toc&s_ti
d=doc_srchtitle

Matlab y sus aplicaciones en las Ciencias y la Ingeniería. Cesar Pérez. Prentice Hall,
Madrid, 2002.
Métodos numéricos – Teoría, problemas y prácticas con MATLAB. Infante del Río J-A. &
Rey Cabezas J. M. 2da Edición - Pirámide. 2002.

mathworks. (s.f.). Recuperado el 13 de enero de 2018, de mathworks:

https://la.mathworks.com/help/matlab/ref/tic.html?searchHighlight=tic&s_tid
=doc_srchtitle

http://personales.unican.es/meperez/GRADO_ICIVIL/practicas/ED_PR3_4_2012_13_en
web.pdf