METODOS ESTADISTICOS Y NUMERICOS - PRACTICAS DE LABORATORIO

Curso 2016-2017 - Grupo B

PRACTICA 4
SESIONES LABORATORIO: 5 - 6

Derivacin e integracin numricas

A. PROGRAMACION
Derivacin numrica mediante lmites:
function

[L, n] = difflim (f, x, toler)

% Entrada - f es la funcion introducida como una cadena de

%caracteres 'f'
%
- x es el punto de diferenciacion
%
- toler es la tolerancia deseada
% Salida
- L = [H', D', E']: H es el vector de tamaos de
% paso (incrementos)
%
D es el vector de derivadas aproximadas
%
E es el vector de las cotas de error
%
- n es la coordenada de la "mejor aproximacion"
max1 =
h = 1;
H(1) =
D(1) =
E(1) =
R(1) =

15;
h;
(feval(f, x+h) - feval(f, x-h)) / (2 * h);
0;
0;

for n = 1:2
h = h / 10;
H(n+1) = h;
D(n+1) = (feval(f, x+h) - feval(f, x-h)) / (2*h);
E(n+1) = abs(D(n+1) - D(n));
R(n+1) = 2*E(n+1) * (abs(D(n+1)) + abs(D(n)) + eps);
end
n = 2;
while ((E(n) > E(n+1)) & (R(n) > toler)) & n < max1
h = h / 10;
H(n+2) = h;
D(n+2) = (feval(f, x+h) - feval(f, x-h)) / (2*h);
E(n+2) = abs(D(n+2) - D(n+1));
R(n+2) = 2 * E(n+2) * (abs(D(n+2)) + abs(D(n+1)) + eps);

n = n + 1;
end
n = length(D) - 1;
L = [H', D', E'];

Derivacin numrica usando extrapolacin:

function

[D, err, relerr, n] = diffext (f, x, delta, toler)

% Entrada % caracteres
%
%
%
% Salida
%
%
%
-

f es la funcion introducida como una cadena de

'f'
x es el punto de diferenciacion
delta es la tolerancia para el error
toler es la tolerancia para el error relativo
D es la matriz de derivadas aproximadas
err es la cota del error
relerr es la cota del error relativo
n es la coordenada de la "mejor aproximacion"

err = 1;
relerr = 1;
h = 1;
j = 1;
D(1, 1) = (feval(f, x+h) - feval(f, x-h)) / (2*h);
while relerr > toler & err > delta & j < 12
h = h / 2;
D(j+1, 1) = (feval(f, x+h) - feval(f, x-h)) / (2 * h);
for k = 1:j
D(j+1, k+1) = D(j+1, k) + (D(j+1, k) - D(j, k)) / ((4^k)-1);
end
err = abs(D(j+1, j+1) - D(j, j));
relerr = 2 * err / (abs(D(j+1, j+1)) + abs(D(j, j)) + eps);
j = j + 1;
end
[n, n] = size(D);

Derivacin numrica usando el polinomio interpolador de Newton:

function

[A, df] = diffnew (X, Y)

% Entrada
- X es el vector de abscisas 1
%
- Y es el vector de ordenadas 1
% Salida
- A es el vector 1 x n, vector
% los coeficientes del
%
polinomio de Newton de grado
%
- df es la derivada aproximada

x n
x n
conteniendo
N

A = Y;
N = length(X);
for j = 2:N
for k = N:-1:j
A(k) = (A(k) - A(k-1)) / (X(k) - X(k-j+1));
end
end

x0 =
df =
prod
n1 =

X(1);
A(2);
= 1;
length(A) - 1;

for k = 2:n1
prod = prod * (x0 - X(k));
df = df + prod * A(k+1);
end

Integracin numrica mediante la regla compuesta del trapecio:

function

s = traprl (f, a, b, M)

% Entrada % caracteres
%
%
% Salida
-

f es ei integrando introducido como cadena de

'f'
a y b son los limites superior e inferior de integracion
M es el numero de subintervalos
s es la suma de la regla trapezoidal (integral)

h = (b - a) / M;
s = 0;
for k = 1:(M-1)
x = a + h * k;
s = s + feval(f, x);
end
s = h *(feval(f, a) + feval(f, b)) / 2 + h * s;

Integracin numrica mediante la regla compuesta de Simpson:

function

s = simprl (f, a, b, M)

% Entrada % caracteres
%
%
% Salida
-

f es el integrando introducido como cadena de

'f'
a y b son los limites superior e inferior de integracion
M es el numero de subintervalos
s es la suma de la regla de simpson

h = (b - a) / (2 * M);
s1 = 0;
s2 = 0;
for k = 1:M
x = a + h * (2 * k - 1);
s1 = s1 + feval(f, x);
end
for k = 1:(M-1)
x = a + h * 2 * k;
s2 = s2 + feval(f, x);
end
s = h * (feval(f, a) + feval(f, b) + 4 * s1 + 2 * s2) / 3;

Integracin numrica mediante la regla recursiva del trapecio:

function

T = rctrap (f, a, b, n)

% Entrada - f es el integrando introducido como cadena de

% caracteres 'f'
%
- a y b son los limites superior e inferior de integracion
%
- n es el numero de veces para recursion
% Salida
- T es la lista de la regla trapezoidal recursiva
M = 1;
h = b - a;
T = zeros(1, n+1);
T(1) = h * (feval(f, a) + feval(f, b)) / 2;
for j = 1:n
M = 2 * M;
h = h / 2;
s = 0;
for k = 1:M/2
x = a + h * (2 * k - 1);
s = s + feval(f, x);
end
T(j+1) = T(j) / 2 + h * s;
end

Mtodo de integracin de Romberg:

function

[R, quad, err, h] = romber (f, a, b, n, tol)

% Entrada % caracteres
%
%
%
% Salida
%
%
%
-

f es el integrando introducido como cadena de

'f'
a y b son los limites superior e inferior de integracion
n es el numero maximo de filas en la tabla
tol es la tolerancia
R es la tabla de Romberg
quad es el valor de la cuadratura (integral)
err es el error estimado
h es el tamao de paso mas pequeo utilizado

M = 1;
h = b - a;
err = 1;
J = 0;
R = zeros(4, 4);
R(1, 1) = h * (feval(f, a) + feval(f, b)) / 2;
while ((err > tol) & (J
J = J + 1;
h = h / 2;
s = 0;
for p = 1:M
x = a + h * (2 * p s = s + feval(f, x);
end
R(J+1, 1) = R(J, 1) / 2
M = 2 * M;
for K = 1:J
R(J+1, K+1) = R(J+1,

< n))

(J < 4)

1);

+ h * s;

K) + (R(J+1, K) - R(J, K)) / (4 ^ K - 1);

end
err = abs(R(J, J) - R(J+1, K+1));
end
quad = R(J+1, J+1);

Mtodo de integracin adaptativa con la regla de Simpson:

function

[SRmat, quad, err] = adapt (f, a, b, tol)

% Entrada - f es el integrando introducido como una

% cadena de caracteres 'f'
%
- a y b son los limites inferior y superior de la
integracion
%
- tol es la tolerancia
% Salida
- SRmat es la tabla de valores
%
- quad es el valor de cuadratura (integral)
%
- err es el error estimado
% Valores iniciales
SRmat = zeros(30,6);
iterating = 0;
done = 1;
SRvec = zeros(1,6);
SRvec = srule(f, a, b, tol);
SRmat(1, 1:6) = SRvec;
m = 1;
state = iterating;
while (state == iterating)
n = m;
for j = n:-1:1
p = j;
SR0vec = SRmat(p, :);
err = SR0vec(5);
tol = SR0vec(6);
if (tol <= err)
% Dividir intervalo, aplicar regla de Simpson
% recursivamente, y determinar el error
state = done;
SR1vec = SR0vec;
SR2vec = SR0vec;
a = SR0vec(1);
b = SR0vec(2);
c = (a + b) / 2;
err = SR0vec(5);
tol = SR0vec(6);
tol2 = tol / 2;
SR1vec = srule(f, a, c, tol2);
SR2vec = srule(f, c, b, tol2);
err = abs(SR0vec(3) - SR1vec(3) - SR2vec(3)) / 10;
% Prueba de exactitud
if (err < tol)
SRmat(p, :) = SR0vec;
SRmat(p, 4) = SR1vec(3) + SR2vec(3);
SRmat(p, 5) = err;
else

SRmat(p+1:m+1, :) = SRmat(p:m, :);

m = m + 1;
SRmat(p, :) = SR1vec;
SRmat(p+1, :) = SR2vec;
state = iterating;
end
end
end
end
quad = sum(SRmat(:, 4));
err = sum(abs(SRmat(:, 5)));
SRmat = SRmat(1:m, 1:6);

Este programa utiliza el subprograma siguiente:

Regla de Simpson:
function

Z = srule (f, a0, b0, tol0)

% Entrada % caracteres
%
integracion
%
% Salida
-

f es el integrando introducido como cadena de

'f'
a0 y b0 son los limites superior e inferior de
tol0 es la tolerancia
Z es un vector 1 x 6 [a0, b0, S, S2, err, tol1]

h = (b0 - a0) / 2;
C = zeros(1, 3);
C = feval(f, [a0, (a0+b0)/2, b0]);
S = h * (C(1) + 4 * C(2) + C(3)) / 3;
S2 = S;
tol1 = tol0;
err = tol0;
Z = [a0, b0, S, S2, err, tol1];

Mtodo de integracin de Gauss-Legendre:

function

quad = gauss (f, a, b, A, W)

% Entrada
% cadena de
%
%
%
% Salida

- f es el integrando introducido como una

caracters 'f'
- a y b limites superior e inferior de integracion
- A es el vector 1 x N de abscisas (nodos) de la Tabla 7.9
- W es el vector 1 x N de pesos de la Tabla 7.9
- quad es el valor de cuadratura

N = length(A);
T = zeros(1, N);
T = ((a + b) / 2) + ((b - a) / 2) * A;
quad = ((b - a) / 2) * sum(W .* feval(f, T));

B. COMANDOS ESPECIFICOS MATLAB

y = diff (x)
Dado un vector x de dimensin n, devuelve un vector de dimensin n-1 a partir
de las diferencias entre puntos contiguos: [x(2)-x(1) x(3)-x(2) ... x(n)-x(n-1)].

q= quad('f ', xmin, xmax, tol, trace, p1, p2, )

funcin MATLAB de integracin adaptativa con la regla de Simpson, siendo
'f': cadena con el integrando
xmin, xmax: lmites de integracin
Parmetros opcionales
tol: tolerancia (error absoluto). Valor por defecto: 1.0e-6.
trace: si distinto de 0 muestra los valores de ejecucin durante el proceso recursivo
p1, p2, : parmetros opcionales (slo si el integrando depende de p1, p2, ).
Ejemplo:
[q, nfev] = quad('f ', 0,pi, 1e-6)

% nfev: nmero de evaluaciones para hacer la integral

q = dblquad('f',xmin,xmax,ymin,ymax,tol,method)
funcin MATLAB de integracin bidimensional del integrando f en un rectngulo de
lmites [xmin,xmax] e [ymin,ymax].

C. EJERCICIOS
1. Calclese f'(x) en x = 1 numricamente, aplicando los mtodo de derivacin mediante
lmites y derivacin usando extrapolacin. Mostrar el error relativo cometido.
f ( x) x
2. Calclese numricamente las derivadas de las funciones siguientes, aplicando los
mtodos de derivacin mediante lmites y derivacin usando extrapolacin:
f ( x) 50 x 35 18 x 2 6
en x=1

1 2 x sin 2 3x
g ( x)
1 x2

en x = 2

dI
RI (t ) , donde R
dt
es la resistencia, L la inductancia e I es la intensidad de corriente. Consideremos
L=0.05H (henrios), R=2 y los valores de I(t), en Amperios se relacionan en la tabla
siguiente.
3. El voltaje en un circuito elctrico obedece la ecuacin V (t ) L

t
I(t)

1.0
1.1
1.2
1.3
1.4
8.2277 7.2428 5.9908 4.5260 2.9122

(a) Determnese I' mediante derivacin numrica (usando el polinomio interpolador

de Newton) y usar ese valor para calcular V, en el instante t=1.2.
(b) Comparar el resultado con el que se tendra utilizando la frmula de derivacin
centrada:
f ( x h) f ( x h )
f ' ( x)
2h

4. (a) Aproximar las derivadas primera y segunda de la funcin

y (t ) 3 cos(10t ) 0.5 et / 5 t 3 2t 2 2t 9 en el intervalo [0,3]. Representa
grficamente y(t), y'(t), y''(t).
(b) Calcular los mnimos locales de la funcin en el intervalo considerado, es decir
encontrar los puntos tm que verifican: y'(tm)=0, y''(tm)>0.

Ayudas:
- Definir el eje de abscisas con un paso de 0.01 (es decir, t=0:0.01:3)
-Aplicar la funcin MATLAB diff para aplicar la frmula de derivacin siguiente:
f ( x h) f ( x)
f ' ( x)
h
- Los puntos crticos pueden determinarse numricamente a partir del cambio de signo
de y'(t), entre dos puntos consecutivos. Es conveniente dibujar los puntos sobre la
funcin original para ver si son mximos o mnimos.
- Puede ser til usar el comando find (para encontrar los puntos crticos y para
clasificarlos)
5. Aproxima las integrales siguientes utilizando la regla compuestas del trapecio y de
Simpson. Comparar el resultado con el que proporciona la funcin MATLAB (quad).
Cuntos intervalos son necesarios en cada mtodo para alcanzar una precisin de 5
cifras decimales?

x
dx
x 4

/4

e3 x sin 2 x dx

x ln x dx

x 3e x dx

6. Aproximar las integrales del problema anterior con una precisin de 7 cifras
decimales considerando el mtodo de integracin de Romberg y el mtodo adaptativo
con regla de Simpson.
7.

a) Aproximar la integral

x1/ 3dx con una precisin de 6 cifras decimales

considerando el mtodo de integracin de Romberg. Cuntas filas contiene la tabla de

aproximaciones generada? Por qu es lenta la convergencia de la sucesin generada?
b) Calcula la misma integral realizando el cambio de variable x=t3 y comenta los
resultados.

8. Estimar

f ( x)dx , siendo f (x) una funcin tabulada de acuerdo a los siguientes

datos experimentales
x
f(x)

0
-1

1
-0.5

2
0

3
1

4
3

5
1

6
0

utilizando las reglas compuestas del rectngulo, del trapecio y de Simpson,

respectivamente.
Ayuda: Dada la cuadratura de nodos: x1=a, x2=a+h, x3=a+h,...., xn=a+(n-1)h,
ba
xn+1=a+nh=b, siendo h
, considerar las siguientes reglas:
n
Rectngulo: f ( x)dx h f1 f 2 f 3 ... f n 1 f n
b

h
f1 2 f 2 2 f3 ... 2 f n 1 2 f n f n 1
2
b
h
Simpson: f ( x)dx f1 4 f 2 2 f 3 4 f 4 2 f 5 ... 2 f n 1 4 f n f n 1
a
3
b

Trapecio: f ( x)dx
a

9. Sin hacer llamadas a rutinas externas, hacer un programa para obtener el rea bajo la
sin( x)
curva exp
en [0,1] utilizando la regla compuesta de Simpson con 6
x
subintervalos.
Ayuda: para evitar la singularidad en x=0, usar crear la funcin sinnx.m
function y =sinxx(x)
% calcula y=sin(x)/x
n=length(x);
for k=1:n
if x(k) ==0
y(k)=1;
else
y(k)=sin(x(k))/x(k);
end
end

1 2x
dx utilizando el mtodo de integracin de Gauss1 x2
Legendre, para 2, 3 o 7 nodos, respectivamente (considerar los respectivos nodos y
pesos en la siguiente tabla).

10. Aproxima la integral

Nodos
0.5773502692
0.7745966692
0.00000000000
0.9491079123
0.7415311856
0.4058451514
0.00000000000

N
2
3
7

Pesos
1.00000000000
0.55555555556
0.88888888888
0.1294849662
0.2797053915
0.3818300505
0.4179591837

11. Calcular las integrales dobles siguientes:

2

dx dy y 2 sin( x ) x 2 cos( y )
0

1
0

dx dy e xy sin( xy )
1