METODOS ESTADISTICOS Y NUMERICOS - PRACTICAS DE LABORATORIO

Curso 2016-2017 - Grupo B

PRACTICA 3
SESIONES LABORATORIO: 4

Interpolacin numrica y
minimizacin de funciones
A. PROGRAMACION
Interpolacin de Lagrange:
function [C, L] = lagran (X, Y)
% Entrada - X es un vector que contiene una lista de las abscisas
%
- Y es un vector que contiene una lista de las ordenadas
% Salida
- C es un vector que contiene los coeficientes del
%
polinomio interpolante de Lagrange
%
- L es una matriz que contiene los coeficientes de los
%
polinomios de Lagrange
w = length(X);
n = w - 1;
L = zeros(w, w);
% Formar los polinomios coeficientes de Lagrange
for k = 1:n+1
V = 1;
for j = 1:n+1
if k ~= j
V = conv(V, poly(X(j))) / (X(k) - X(j));
end
end
L(k, :) = V;
end
% Determinar los coeficientes del polinomio interpolador de Lagrange
C = Y * L;

Polinomio interpolador de Newton:

function [C, D] = newpoly (X, Y)
% Entrada
- X es un vector que contiene la lista de abscisas
%
- Y es un vector que contiene la lista de ordenadas
% Salida
- C es un vector que contiene los coeficientes del
%
polinomio interpolante de Newton
%
- D es la tabla de diferencias divididas
n = length(X);

D = zeros(n, n);
D(:, 1) = Y';
% formar la tabla de diferencias divididas
for j = 2:n
for k = j:n
D(k, j) = (D(k, j-1) - D(k-1, j-1)) / (X(k) - X(k-j+1));
end
end
% Determinar los coeficientes del polinomio interpolante de Newton
C = D(n, n);
for k = (n-1):-1:1
C = conv(C, poly(X(k)));
m = length(C);
C(m) = C(m) + D(k, k);
end

Minimizacin de funciones mediante el mtodo de la seccin urea:

function

[S, E, G] = golden (f, a, b, delta, epsilon)

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

caracteres 'f'
%
- a y b son los extremos del intervalo
%
- delta es la tolerancia para las abscisas
%
- epsilon es la tolerancia para las ordenadas
% Salida
- S = (p, yp) contiene la abscisa p y
%
la ordenada yp del minimo
%
- E = (dp, dy) contiene las estimaciones de error para p
y yp
%
- G es una matriz n x 4: la k-esima fila contiene [ak,
ck, dk, bk];
%
los valores de a, c, d, y b en la k-esima iteracion
r1 = (sqrt(5) - 1) / 2;
r2 = r1^2;
h = b - a;
ya = feval(f, a);
yb = feval(f, b);
c = a + r2 * h;
d = a + r1 * h;
yc = feval(f, c);
yd = feval(f, d);
k = 1;
A(k) = a; B(k) = b; C(k) = c; D(k) = d;
while (abs(yb-ya) > epsilon)
k = k + 1;
if (yc < yd)
b = d;
yb = yd;
d = c;
yd = yc;
h = b - a;
c = a + r2 * h;
yc = feval(f, c);
else
a = c;
ya = yc;
c = d;

(h > delta)

yc = yd;
h = b - a;
d = a + r1 * h;
yd = feval(f, d);
end
A(k) = a; B(k) = b; C(k) = c; D(k) = d;
end
dp = abs(b - a);
dy = abs(yb - ya);
p = a;
yp = ya;
if

(yb < ya)

p = b;
yp = yb;
end
G = [A', C', D', B'];
S = [p, yp];
E = [dp, dy];

Minimizacin de funciones mediante el mtodo SIMPLEX:

function [V0, y0, dV, dy] = nelder (F, V, min1, max1, epsilon, show)
% Entrada
- F es la funcion objetivo introducida como cadena de
caracteres 'F'
%
- V una matriz 3 x n conteniendo el inicio de simplex
%
- min1 & max1: los numeros minimo y maximo de iteraciones
%
- epsilon es la tolerancia
%
- show == 1 despliega las iteraciones (P y Q)
% Salida
- V0 es el vertice para el minimo
%
- y0 es valor de la funcion F(V0)
%
- dV es el tamao del final de simplex
%
- dy es limite de error para el minimo
%
- P matriz conteniendo los vertices de cada iteracion
%
- Q es un arreglo conteniendo las iteraciones para F(P)
if nargin == 5,
show = 0;
end
[mm, n] = size(V);
% Ordenar los vertices
for j = 1:n+1
Z = V(j, 1:n);
Y(j) = feval(F, Z);
end
[mm, lo] = min(Y);
[mm, hi] = max(Y);
li = hi;
ho = lo;
for j = 1:n+1
if (j ~= lo & j ~= hi & Y(j) <= Y(li))
li = j;
end
if (j ~= hi & j ~= lo & Y(j) >= Y(ho))
ho = j;
end
end
cnt = 0;

% Iniciar el algoritmo de Nelder-Mead

while (Y(hi) > Y(lo) + epsilon & cnt
S = zeros(1, 1:n);
for j = 1:n+1
S = S + V(j, 1:n);
end
M = (S - V(hi, 1:n)) / n;
R = 2 * M - V(hi, 1:n);
yR = feval(F, R);
if (yR < Y(ho))
if (Y(li) < yR)
V(hi, 1:n) = R;
Y(hi) = yR;
else
E = 2 * R - M;
yE = feval(F, E);
if (yE < Y(li))
V(hi, 1:n) = E;
Y(hi) = yE;
else
V(hi, 1:n) = R;
Y(hi) = yR;
end
end
else
if (yR < Y(hi))
V(hi, 1:n) = R;
Y(hi) = yR;
end
C=(V(hi, 1:n) + M) / 2;
yC = feval(F, C);
C2 = (M + R) / 2;
yC2 = feval(F, C2);
if (yC2 < yC)
C = C2;
yC = yC2;
end
if (yC < Y(hi))
V(hi, 1:n) = C;
Y(hi) = yC;
else
for j = 1:n+1
if (j ~= lo)
V(j, 1:n) = (V(j, 1:n) +
Z = V(j, 1:n);
Y(j) = feval(F, Z);
end
end
end
end
[mm, lo] = min(Y);
[mm, hi] = max(Y);
li = hi;
ho = lo;
for j = 1:n+1
if (j ~= lo & j ~= hi & Y(j)
li = j;
end
if (j ~= hi & j ~= lo & Y(j)
ho = j;
end

< max1)

cnt < min1

V(lo, 1:n)) / 2;

<= Y(li))

>= Y(ho))

end
cnt = cnt + 1;
P(cnt, :) = V(lo, :);
Q(cnt) = Y(lo);
end
% Final del algoritmo de Nelder-Mead
% Determinar el tamao de simplex
snorm = 0;
for j = 1:n+1
s = norm(V(j) - V(lo));
if (s >= snorm)
snorm = s;
end
end
Q = Q';
V0 = V(lo, 1:n);
y0 = Y(lo);
dV = snorm;
dy = abs(Y(hi) - Y(lo));
if

(show == 1)
disp(P);
disp(Q);
end

B. COMANDOS ESPECIFICOS MATLAB

EVALUACIN DE FUNCIONES POLINMICAS
y = polyval(p,x)
Devuelve el valor del polinomio p evaluado en los puntos del vector x. Para un
polinomio de grado n, p ser un vector de dimensin n+1, cuyos elementos son los
coeficientes de las potencias (ordenadas de forma descendente):
y= p(1)*x^n + p(2)*x^(n-1) + ... + p(n)*x + p(n+1)
v=ppval (p, x)
Evala el polinomio p, definido a trozos, para una lista de valores del vector x.
Generalmente el polinomio a trozos se habr construido previamente con los
comandos spline o interp1.

INTERPOLACIN UNIDIMENSIONAL
yi = interp1(x, y, xi, mtodo)
Dado un conjunto de puntos, cuya abcisa y ordenada, respectivamente, viene dada
por los vectores x, y, devuelve yi , vector de valores interpolados correspondientes al
vector de abcisas xi . mtodo es una cadena opcional para indicar el mtodo de
interpolacin, siendo las opciones ms habituales:
'nearest': Funcin constante a trozos (Vecino ms cercano)
'linear': Interpolacin lineal a trozos (mtodo por defecto)
'cubic': Interpolacin cbia a trozos
'spline': Interpolador con splines cbicas
yi = spline (x, y, xi)
5

funcin equivalente a interp1 haciendo metodo='spline'

pp = spline(x, y)
devuelve una estructura con los coeficientes polinmicos de la interpolacin con
splines
Ejemplo:
>> struct(pp)
ans =
form: 'pp'
breaks: [0 0.6283 1.2566 1.8850 2.5133 3.1416]
coefs: [5x4 double]
pieces: 5
order: 4
dim: 1
>> pp.coefs
ans =
0.0859 -1.8265 2.6274
0
0.0859 -1.6646 0.4338 0.9511
1.5944 -1.5027 -1.5563 0.5878
0.0859 1.5027 -1.5563 -0.5878
0.0859 1.6646 0.4338 -0.9511

INTERPOLACIN BIDIMENSIONAL
zi = interp2(X, Y, Z, xi, yi, mtodo)
Interpola los valores de zi para posiciones dadas por los vectores (xi,yi). La funcin
se Z(X,Y) se aproxima considerando valores en las posiciones dadas por las matrices
X,Y (X e Y generalmente se generan habitualmente con meshgrid). El tipo de
funcin polinmica se selecciona con la cadena mtodo: 'nearest','linear', 'cubic' o
'spline'
MINIMIZACIN DE FUNCIONES
f=inline(expr, arg1, arg2, ...)
Declara una funcin f de varias variables dadas por los argumentos arg1, arg2, ...
Ejemplos:
f=inline('(1+x)^2/(1+x^2)','x') % funcin de una variable, x es un escalar
f=inline('(x(1)-3)^2+x(2)^2','x'); % funcin de 2 variables, x es un vector

f=fminbnd(mifuncion, min, max,opciones)

Devuelve un mnimo local de la funcin f en el rango [min,max] aplicando un
algoritmo de golden search en combinacin con interpolacin cuadrtica
Ejemplos
x=fminbnd(f,0,4, optimset('TolX',1e-6,'MaxIter',3,'TolFun',0.0001) %
mnimo de 'f' entre 0 y 4, en el que se especifica diversas condiciones de parada
(convergencias, mximo nmero de iteraciones)
[x,fval,exitflag,output]=fminbnd(f,0,4) % proporciona parmetros adicionales,
tales como fval (funcin en el mnimo) e informacin adicional

f=fminsearch(f, x0,opciones)
Devuelve un mnimo local de la funcin 'f' utilizando el algoritmo SIMPLEX,
siendo x0 un valor inicial de bsqueda. Las opciones son similares a las del mtodo
minbnd.

C. EJERCICIOS
1. Interpolacin polinmica. De un muelle con un extremo fijo colgamos distintas
masas y obtenemos la tabla siguiente
10
67

M (kg)
L (m)

20
122

30
195

Utilizar la interpolacin cuadrtica para estimar la longitud del muelle para masas de 12,
16, 19 y 25 kg, indicar el polinomio de interpolacin y representar grficamente el
resultado.
Ayuda: El polinomio de segundo grado p2 ( x ) a1 x 2 a 2 x a 3 que pasa por (x1,y1), (x2,y2) y
(x3,y3) se determina resolviendo el sistema:

a1 x12 a 2 x1 a3 y1
a1 x 22 a 2 x 2 a 3 y 2
a1 x32 a 2 x3 a3 y 3
Sugerencia: utilizar la funcin vander(). Por ejemplo, dado el vector x(x1, x3, x3) se tiene:

x12

vander ( x ) x 22
x2
3

x1 1

x 2 1
x 3 1

2. Dada la siguiente tabla de valores:

x
f(x)

2
0.7

3
0.5

4
0.2

5
0.1

encuentre el valor de la funcin para x = 2.5 mediante interpolacin de polinmica de

Newton tomando (a) dos puntos, (b) tres puntos y (c) cuatro puntos.
3. Aplicar el mtodo de interpolacin cbica con splines para aproximar f(x) =
cos(2x+0.3) en el rango [0, ], utilizando los valores dados por f(x) en x = 0, /5, 2/5,
3/5, 4/5, . Representar grficamente la curvas interpolada, as como la de la
funcin cos(2x+0.3). Calcular el valor absoluto medio del residuo (diferencia entre
ambas curvas). Comparar los resultados con los obtenidos con el mtodo de
interpolacin cbica.

4. Repetir los clculos del problema anterior considerando otros mtodos de

interpolacin ms simples (vecino ms cercano, lineal) y hacer un anlisis comparativo
de los resultados obtenidos.
5. Aplicar el mtodo de interpolacin cbica con splines para aproximar f(x) = e-x en el
rango [0, 1], utilizando los valores dados por f(x) en x = 0, 0.25, 0.75, 1.0. Cuntos
polinomios se han utilizado en la interpolacin con splines? Detalla la expresin de los
dos primero polinomios.
6. Interpolacin bidimensional. Aplicar los mtodos de interpolacin lineal y cbica de
la funcin bi-variada z(x,y) = sin(x2 + 3y2) , 1x1, -1y1, utilizando los valores
dados por z(x,y) en los puntos x={-1,-0.5,0,0.5,1}, y={-1,-0.5,0,0.5,1}. Representar
grficamente las curvas interpoladas correspondientes a los diferentes resultados, as
como la de la funcin original z(x,y) para poder compararlas.
7. Aplicar el mtodo de golden search para encontrar el valor mximo de la funcin
(1 x ) 2
f ( x)
1 x2
en el intervalo [0,4] con una precisin de 7 cifras decimales.
8. Repetir el clculo del problema anterior para encontrar el mnimo de la funcin
2
1
f ( x) 2 e x
x
en el intervalo [0.5,1.5].
9. Aplicar el algoritmo simplex para encontrar el valor mnimo de las siguientes
funciones de dos variables
f ( x, y ) 0.5( x 1.3) 2 2.5( y 0.2) 2
2

f ( x, y ) 20( y x 2 ) 2 ( x 0.75) 2 2e 5( x y )
con una precisin de 7 cifras decimales. Utilizar tanto la funcin "nelder" como la
funcin MATLAB "fminsearch" y comparar los resultados. Considerar la posible
dependencia con los parmetros utilizados (valores iniciales de la bsqueda y nmero de
iteraciones).