UNIVERSIDAD POLITÉCNICA DE MADRID ESCUELA TÉCNICA SUPERIOR DE INGENIEROS DE MINAS DEPARTAMENTO DE MATEMÁTICA APLICADA Y MÉTODOS INFORMÁTICOS

Transcripción

1 UNIVERSIDAD POLITÉCNICA DE MADRID ESCUELA TÉCNICA SUPERIOR DE INGENIEROS DE MINAS DEPARTAMENTO DE MATEMÁTICA APLICADA Y MÉTODOS INFORMÁTICOS TITULACIÓN: INGENIERÍA DE MINAS ASIGNATURA: PROGRAMACIÓN Y MÉTODOS NUMÉRICOS PRÁCTICA Nº 7: INTERPOLACIÓN POLINÓMICA DE LAGRANGE (II): Diferencias divididas. Fórmula de Newton. Diferencias Finitas. INTRODUCCIÓN A LA INTERPOLACIÓN POLINÓMICA DE HERMITE CURSO PRÁCTICA ELABORADA POR: Prof. Carlos Conde Lázaro Prof. Arturo Hidalgo López Prof. Alfredo López Benito Depto. de Matemática Aplicada y Métodos Informáticos Escuela Técnica Superior de Ingenieros de Minas Universidad Politécnica de Madrid Mayo 2007

2 OBJETIVOS DE LA PRÁCTICA 1º. Aplicar métodos en diferencias dividas para el cálculo del polinomio interpolador de Lagrange. 2º. Utilizar métodos en diferencias finitas para el cálculo del polinomio interpolador de Lagrange. 3º. Introducir algoritmos de interpolación de Hermite. 4º. Elaborar procedimientos de interpolación. FORMA DE DESARROLLAR ESTA PRÁCTICA. El desarrollo de la práctica consistirá en la realización de ejemplos resueltos (epígrafe de EJEMPLOS) y tras ello se propone al alumno el desarrollo de algunos ejercicios (epígrafe de EJERCICIOS PROPUESTOS) que deberá desarrollar individualmente. DURACIÓN ESTIMADA DE ESTA PRÁCTICA El tiempo estimado para la realización de esta práctica es de 2 horas. BIBLIOGRAFÍA Algunos de los ejercicios de esta práctica están basados en los recogidos en: (2007) Interpolación polinómica. Apuntes disponibles en el Open Course Ware de la Universidad Politécnica de Madrid 1

3 EJEMPLOS Primer ejemplo: Método de diferencias divididas: construcción de la tabla de diferencias divididas; obtención del polinomio interpolador de Lagrange mediante la fórmula de Newton. Comencemos escribiendo un procedimiento para el cálculo de la tabla de diferencias divididas. Dicha tabla tiene la forma: x 0 f[ x 0 ] f[ x 0, x 1 ]... f[ x 0, x 1,..., x j ]... f[ x 0, x 1,..., x n 1 ]... f[ x 0, x 1,..., x n ] x 1 f[ x 1 ] f[ x 1, x 2 ]... f[ x 1, x 2,..., x j + 1 ]... f[ x 1, x 2,..., x n ] x i f[ x i ]... f[ x i, x i + 1 ]... f[ x i, x i + 1,..., x i+ j ]... x n f[ x n ]... Cada elemento de la tabla anterior se puede calcular mediante la expresión: f x,x,...,x f x,x,...,x A A i+ 1 i+ 1 i+ j i i+ 1 i+ j 1 i+ 1,j 1 i,j 1 = i,j i i+ 1 i+ j 1 i+ j = = xi+ j xi xi+ j xi A f x,x,...,x,x es decir mediante un cociente en el que en el numerador aparece la diferencia entre el elemento que está en la fila superior y columna anterior menos el el que está en la misma fila y columna anterior, y en el denominador está la diferencia entre la abscisa de soporte (i+j) -ésima menos la abscisa del soporte i-ésima. Esta es la expresión que se utiliza en el procedimiento siguiente, en el que los puntos del soporte se consideran un dato proporcionado en el vector s. También son datos el indicador del número de puntos, n (hay n+1) puntos de soporte) y la función f. EL parámetro de salida es la tabla denominada tabla en la que los elementos no calculados tienen valor nulo. 2

4 Procedimiento de cálculo de la tabla de diferencias divididas sobre un soporte dado restart; tabdifdiv:=proc(n,s,f,tabla) local fval, i, j: fval:=array(0..n): for i from 0 by 1 to n do fval[i] := f(s[i]): for i from 0 by 1 to n do for j from 0 by 1 to n do tabla[i,j]:=0.; for i from 0 by 1 to n do tabla[i,0] := fval[i]: for j from 1 by 1 to n do for i from 0 by 1 to (n-j) do tabla[i,j]:=(tabla[i+1,j-1]-tabla[i,j-1]) / (s[i+j]-s[i]): end proc: save tabdifdiv,"tabdifdiv.m": fin_del_procedimiento; fin_del_procedimiento Con la tabla de diferencias divididas puede calcularse fácilmente el polinomio interpolador mediante la fórmula de Newton n [ ] [ ] = + (i 1) p n(x) f s0 f s 0,...,s i (x s j) i= 1 j= 0 Esta fórmula, denominada fórmula de Newton, es la que se programa en el procedimiento siguiente: 3

5 Procedimiento para el cálculo del polinomio interpolador mediante la fórmula de Newton restart; polnew:=proc(n,s,tabla,p) local aux, aux1,j, suma: suma:=0: for j from 1 to n by 1 do aux:=mul((x-s[k]),k=0..j-1): aux1:=tabla[0,j]*aux: suma:=suma+aux1: p:=x-tabla[0,0]+suma: end: save polnew,"polnew.m": fin_del_procedimiento; fin_del_procedimiento Apliquemos los procedimientos anteriores a la construcción del polinomio interolador de una función sobre un soporte. restart; with(linalg):with(plots): Warning, the protected names norm and trace have been redefined and unprotected Warning, the name changecoords has been redefined Definimos, inicialmente, la función a interpolar. Sea la función f(x)=x sin(x) definida en el intervalo [0, 3π/2]: f := x-x*sin(x); f := x x sin( x ) Como puntos del soporte tomaremos un soporte equidistante: {0, π/2, p, 3π/2} n := 3: 4

6 h := Pi/2: s := array (0..n): s[0] := 0; s 0 := 0 for i from 1 by 1 to n do s[i] := evalf(s[i-1] + h); od; s 1 := s 2 := s 3 := Evaluamos las diferencias divididas de esta función sobre el soporte considerado: read "tabdifdiv.m": tabla:=array(0..n,0..n): tabdifdiv(n,s,f,tabla): La tabla así calculada no tiene estructura de matriz (pues para MAPLE sólo son matrices las variables con dos subíndices en las que el límite inferior de ambos subíndices es 1, cosa que no ocurre con "tabla"). En efecto si la escribes puedes observar lo que MAPLE escribe: evalm(tabla); tabla print(tabla); array( 0.. 3, 0.. 3, [ ( 0, 0) = 0 ( 0, 1 ) = ( 0, 2 ) = ( 0, 3 ) = ( 1, 0 ) = ( 1, 1 ) = ( 1, 2 ) = ( 1, 3) = 0. ( 2, 0 ) =

7 ( 2, 1 ) = ( 2, 2) = 0. ( 2, 3) = 0. ( 3, 0 ) = ( 3, 1) = 0. ( 3, 2) = 0. ( 3, 3) = 0. ]) Si la quieres ver escrita en forma de matriz puedes construir una matriz (aquí llamada "tablar") en la que almacenes los valores de la tabla como se muestra a continuación: tablar:=matrix(n+1,n+1): for i from 1 to n+1 by 1 do for j from 1 to n+1 by 1 do tablar[i,j]:=tabla[i-1,j-1]: evalm(tablar); Calculemos ahora el polinomio interpolador de Lagrange utilizando la fórmula de Newton (y para ello usando el procedimiento polnew que escribimos anteriormente): read "polnew.m": polnew(n,s,tabla,p): expand(p(x)); x x x 3 Dibujemos por últimodel polinomio interpolador y la función interpolada 6

8 dibp:=plot(p(x),x=s[0]..s[n],color=red): dibf:=plot(f(x),x=s[0]..s[n],color=blue): leypol := textplot([1,-1,`polinomio`],color=red): leyfun := textplot([1,-3,`función`],color=blue): display({dibp,dibf,leypol,leyfun}); fin; fin Segundo ejemplo: Caso de soportes equidistantes: Método de diferencias finitas progresivas; fórmula de Newton-Gregory progresiva. Los métodos de interpolación también te permiten calcular las expresiones polinómicas generales a las que responden sumatorios, si consideras el sumatorio 7

9 como una función de la que conoces su valor en valores enteros y evalúas el polinomio interpolador en un valor n supuesto entero. La única dificultad que ello te puede plantear es la de determinar el número de puntos de soporte. Pero ello lo puedes resolver analizando el orden a partir del cual se anulan las diferencias divididas (o finitas). Puesto que puedes evaluar los primeros valores del sumatorio en los primeros enteros es cómodo utilizar soportes equidistantes formados por los primeros números naturales (y, en su caso, el 0). Ilustremos lo anterior obteniendo mediante la fórmula progresiva de Newton- Gregory el polinomio interpolador de la función: Parte entera(x) 3 i= 0 f(x) = i x 0 sobre el soporte formado por el mínimo número de puntos que sea necesario para obtener un valor exacto cuando x sea un número natural. restart; with(linalg):with(plots): Warning, the protected names norm and trace have been redefined and unprotected Warning, the name changecoords has been redefined Warning, the name arrow has been redefined Determinación del número mínimo de abscisas en el soporte Determinemos el número de puntos estrictamente necesario. Para ello definimos la función: f := x-sum(y^3,y=0..x); f := x x y 3 y = 0 Si denotamos por "k" a la distancia que separe dos puntos consecutivos del soporte, podemos definir la diferencia finita progresiva en un punto genérico "x" de la forma: df1:=x-simplify(f(x+k)-f(x)): 8

10 lo que nos conduce a que estas diferencias finitas progresivas de primer orden en un valor un punto "i" del soporte tomarán el valor: df1(i); k3 4 k4 2 i2 k 2 ik2 i 3 3 k 2 i2 k 2 ik ik 1 4 k2 Análogamente las diferencias finitas progresivas de segundo orden en un punto "x" del soporte anterior podrían definirse mediante df2:=x-simplify(df1(x+k)-df1(x)): por lo que en un punto "i" del soporte: df2(i); 3 k k4 3 ik 2 3 i 2 k 2 6 ik k2 Procediendo de la misma forma con las diferencias finitas progresivas de orden 3 y 4 se tiene que: df3:=x-simplify(df2(x+k)-df2(x)): df3(i); 3 k k ik 3 df4:=x-simplify(df3(x+k)-df3(x)): df4(i); 6 k 4 En este último valor obtenido podemos observar que las diferencias finitas progresivas de orden 4 son constantes (6 k) independientes del punto en el que se evalúen. Ello nos indica que todas las diferencias finitas progresivas de orden 5 o superior serán nulas. En efecto, comprobémoslo: df5:=x-simplify(df4(x+k)-df4(x)): df5(i); 0 9

11 Puesto que para todo polinomio de grado menor o igual que n se anulan las diferencias finitas progresivas de order (n+1), la expresión que estamos buscando será en este caso una expresión polinómica de cuarto grado. Y por ello podrá definirse de forma exacta con un soporte de 5 puntos. fin_apartado; fin_apartado Según lo anterior definimos un soporte de 5 puntos (por simplicidad los 5 primeros números naturales) y los valores del sumatorio en ellos n:=4: s:=array(0..n,[1,2,3,4,5]): fval:=array(0..n,[seq(f(s[i]),i=0..n)]): Construyamos la tabla de diferencias progresivas. Ello se hace en el siguiente procedimiento Procedimiento de construcción de la tabla de diferencias finitas progresivas Calculemos la tabla de diferencias finitas progresivas x f f f f f 0 1 (n i) (n 1) (n) 0 Δ 0 Δ 0 Δ 0 Δ 0 Δ (n i) (n 1) 1 Δ 1 Δ 1 Δ 1 Δ 1 x f f f f x Δ f Δ f Δ f x 0 1 (n i) i i i i n Δ f 0 n En la tabla que se calcula (almacenada con el nombre de tabla), no se incluye la columna del soporte. La columna cero de la tabla de diferencias (las de orden 0) son los valores de la función (almacenados en el vector f). El resto de la tabla se va calculando por columnas teniendo en cuenta que: a) El cálculo se realiza por columnas b) El la columna "j" sólo existirán las filas 0 a (n-j) 10

12 c) El elemento "(i, j)" es la diferencia entre el elemento "(i+1,j-1)" y el elemento "(i, j-1)" ambos situados en la columna anterior a aquela en que se calcula y en la fila siguiente y actual respectivamente a aquella en que se calcula. difinpro:=proc(n,f,tabla) local i, j: tabla:=array(0..n,0..n): for i from 0 to n by 1 do tabla[i,0]:=f[i]: for j from 1 by 1 to n do for i from 0 by 1 to (n-j) do tabla[i,j] := tabla[i+1,j-1]-tabla[i,j-1]: end proc: save difinpro, "difinpro.m": fin_procedimiento; fin_procedimiento Utlicemos el procedimiento anterior para calcular nuestra tabla de diferencias finitas progresivas. (Aunque si has ejecutado el procedimiento anterior no sería necesario leerlo por no haber reiniciado, introducimos la sentencia de lectura por si no se hubiera ejecutado el procedimiento en el momento de realizar lo que sigue) read "difinpro.m": difinpro(n,fval,tabla5): Podríamos escribir (con ayuda de la instrucción print) la tabla anterior (bastaría con escribir "print(tabla5);" para ello). Pero para poder ver la tabla con forma de matriz, procederemos previamente a almacenarla en una matriz en lugar de un array (incrementando en una unidad el índice de fila y columna): AUX:=matrix(n+1,n+1): for i from 0 to n by 1 do for j from 0 to n by 1 do 11

13 AUX[i+1,j+1]:=tabla5[i,j]: evalm(aux); tabla5 1, tabla5 2, 3 tabla5 2, tabla5 3, 2 tabla5 3, 3 tabla5 3, tabla5 4, 1 tabla5 4, 2 tabla5 4, 3 tabla5 4, 4 Construyamos un procedimiento que nos permita aplicar la fórmula de Newton- Gregory progresiva. Procedimiento sobre el uso de la fórmula de Newton Gregory Recordemos que en un soporte equidistante s[i] = s[0] + i h, la aplicación de la fórmula de Newton Gregory consiste en realizar el cambio de variable (de "x" a "t") dado por x = s[0] + t h. En la nueva variable el polinomio interpolador estaría dado por la expresión: = n t (i) p(t) Δ f0 i= 0 i donde: t t! t (t 1)... (t i + 1) = = i (t i)! i! i! En el procedimiento que sigue son datos de entrada el indicador de puntos del soporte (n) y la la primera fila de la tabla de diferencias finitas progresivas. El resultado es el polinomio (p) en la variable "t". newgrepro:=proc(n, tabla0, p) local aux, i, comb: comb:=array(0..n): for i from 0 to n by 1 do comb[i]:=mul(t-j,j=0..i-1): comb[i]:=comb[i]/i!: aux:=0: for i from 0 by 1 to n do aux := aux + comb[i]*tabla0[i]: 12

14 p:=unapply(aux,t): end proc: save newgrepro, "newgrepro.m": fin_procedimiento; fin_procedimiento Apliquemos la fórmula de Newton-Gregory progresiva diffin0:=array(0..n,[seq(tabla5[0,i],i=0..n)]): read "newgrepro.m": newgrepro(n, diffin0, p); 19 t t t ( t 1) 3 t ( t 1 ) ( t 2 ) 1 4 t ( t 1 ) ( t 2 ) ( t 3 ) Como en este caso el cambio realizado a la variable t fue: x = s[0] + t h, con s[0] = 1 y h = 1 se puede escribir que t = (x-s[0])/h, es decir: h:=s[1]-s[0]: t:=(x-s[0])/h; t := x 1 p:=unapply(p(t),x); p := x x + 2 ( x 1 ) ( x 2) + 3 ( x 1 ) ( x 2 ) ( x 3 ) ( x 1 ) ( x 2 ) ( x 3 ) ( x 4 ) Luego la expresión buscada para el expand(p(m)); m 3 i= 0 i es: m2 2 m3 4 m4 Dibujamos ahora el polinomio intepolador y la función en el intervalo [0, 7]: poldib := plot(p(x),x=0..7,color=black): fundib := plot(f,0..7,color=blue): leypol := textplot([2,400,`polinomio`],color=black): leyfun := textplot([2,360,`función`],color=blue): display({poldib,fundib,leypol,leyfun}); 13

15 fin_ejemplo; fin_ejemplo Tercer ejemplo: Interpolación de Hermite: Caso general desarrollado a través de la resolución de un sistema lineal de ecuaciones Nos planteamos en este ejemplo encontrar un polinomio p(x) que en (n+1) abscisas distintas {s 0, s 1,., s n } verifique las condiciones siguientes: Las ( ) ( ) ( ) p (j (s ) = f (j (s ) (j = 0,..., α ); (i = 0,1,...,n) i i i n 0 1 n i i= 0 α α α + 1 = n+ 1 + α condiciones anteriores permitirán establecer (m+1) ecuaciones, donde hemos denotado por m al valor: n i= 0 m= n + α. Por tanto se podrán determinar así (m+1) incógnitas (coeficientes del polinomio buscado) lo que nos lleva a que para que el problema esté bien formulado (admita i 14

16 solución única) el polinomio p(x) debe buscarse entre los polinomios de grado menor o igual que m. De forma más detallada, siendo p(x) = c 1 + c 2 x + c 3 x c m+1 x m l el polinomio buscado, los coeficientes del sistema serán solución del sistema de ecuaciones [VM] {c} = {b}, donde la matriz VM tiene (m+1) filas y el mismo número de columnas y los vectores {b} y {c} tienen (m+1) elementos siendo los del vector {c} los coeficientes buscados. Los elementos de la matriz [VM] se obtienen fácilmente a través de las expresiones: 0 si j< r+ 1 = = α = α = + i 1 VM k,j (j 1)! (con k r 1 i q); (k 0,..., i); (i 0,1,...,n) si j r 1 q= 0 (j r 1)! Asimismo los elementos del vector {b} se obtendrá mediante: (i 1) (j k i q i q= 0 b = f (s ) (con k = 1+ i + j + α ); (j = 0,..., α ); (i = 0,...,n) Se deja como ejercicio propuesto obtener las expresiones anteriores. A continuación escribimos un procedimiento que permite construir la matriz y el vector de segundos términos de este sistema Procedimiento para el cálculo del sistema de ecuaciones que proporcione los coeficientes del polinomio interpolador de Hermite En el procedimiento siguiente se usan los siguientes parámetros: Parámetros de entrada: n Indicador del número de abscisas del soporte (hay (n+1) abscisas) s array de (n+1) elementos (con subíndice comprendido entre 0 y n ambos inclusive) conteniendo las abscisas del soporte alpha array de (n+1) números naturales (con subíndice comprendido entre 0 y n ambos inclusive) conteniendo para cada punto del soporte el número de derivadas del polinomio y de la función que se hacen coincidir en él. f función que se interpola en el sentido de Hermite 15

17 Parámetros de salida: VM Matriz del sistema de ecuaciones lineales (ver descripción anterior). Tiene dimensiones (m+1, m+1) b Vector de segundo término del sistema (tiene (m+1) elementos. Además se utilizan las siguientes variables auxiliares: m indicador del grado máximo del polinomio buscado (ver descripción anterior). m1 es el número natural dado por m+1 i variable de control en bucle (indica el índice del punto del soporte en el que se plantean las ecuaciones) j variable de control en bucles (indica la columna de la matriz del sistema en la que se esté calculando el elemento) k variable que irá conteniendo el índice de la fila en la que se calculan elementos ll variable de control en bucles (indicará el orden de derivación correspondiente a la fila en la que se calcule). sisthermite:=proc(n,s,alpha,f,vm, b) local i,j,m, m1, k, ll: m:=add(alpha[i],i=0..n)+n: m1:=m+1: VM:=matrix(m1,m1): b:=vector(m1): k:=1: for i from 0 to n by 1 do for j from 1 to m1 by 1 do VM[k,j]:= s[i]^(j-1): b[k]:=f(s[i]): k:=k+1: if (alpha[i]0) then for ll from 1 to alpha[i] by 1 do for j from 1 to ll by 1 do VM[k,j]:=0: 16

18 for j from ll+1 to m1 by 1 do VM[k,j]:=((j-1)!/(j-1-ll)!)*s[i]^(j-1-ll): b[k]:=(d@@ll)(f)(s[i]): k:=k+1: fi: end proc: save sisthermite, "sisthermite.m": Cálculo del polinomio interpolador de Hermite Utilicemos el procedimiento anterior para calcular el polinomio p(x) que interpola a la función: f(x) = 1 1 x + 2 verificando que: p(-2) = f(-2), p'(-2) = f'(-2), p"(-2) = f"(-2) p(-1) = f(-1), p'(-1) = f'(-1), p(0) = f(0), p'(0) = f'(0), p"(0) = f"(0) p(1) = f(1), p'(1) = f'(1), p(2) = f(2), p'(2) = f'(2), p"(2) = f"(2) restart; with(linalg): with(plots): Warning, the protected names norm and trace have been redefined and unprotected Warning, the name changecoords has been redefined Cargamos el procedimiento read "sisthermite.m": 17

19 Definimos el indicador del número de puntos (n, habiendo (n+1) puntos), el soporte (s), el número de derivadas que se hacen coincidir en cada abscisa del soporte (alpha) y calculamos el grado del polinomio (m). n:=4: s:=array(0..n,[-2,-1, 0, 1, 2]): alpha:=array(0..n,[2,1,2,1,2]): m:=add(alpha[i],i=0..n)+n: m1:=m+1: Definimos la función a interpolar f:=x-1./sqrt(1+x^2); f := x x 2 Usamos el procedimiento anterior para calcular la matriz y vector de segundo término del sistema lineal a resolver: sisthermite(n,s,alpha,f,vm, b); 14 Escribimos la matriz y vector calculados: evalm(vm); 18

20 1, -2, 4, -8, 16, -32, 64, -128, 256, -512, 1024, -2048, , 1, -4, 12, -32, 80, -192, 448, -1024, 2304, -5120, 11264, , 0, 2, -12, 48, -160, 480, -1344, 3584, -9216, 23040, , , -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1 0, 1, -2, 3, -4, 5, -6, 7, -8, 9, -10, 11, -12 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, , 1, 4, 12, 32, 80, 192, 448, 1024, 2304, 5120, 11264, , 0, 2, 12, 48, 160, 480, 1344, 3584, 9216, 23040, 56320, evalm(b); [ , , , , , 1., 0., -1., , , , , ] Calculamos el vector de coeficientes (resolviendo el sistema de ecuaciones anterior) c:=evalm(inverse(vm)&*b); c := [ 1., 0., , , , 0., , , , , , 0., ] Calculamos el polinomio interpolador de Hermite buscado p:=0: for i from 1 to m1 by 1 do p:=p+c[i]*x^(i-1): p:=simplify(p): 19

21 p:=unapply(p,x); p := x x x x x x x x x x 12 Representamos en una misma gráfica el polinomio interpolador y la función interpolada: dibf:=plot(f,s[0]..s[n],color=blue, thickness=3): dibp:=plot(p,s[0]..s[n],color=red, thickness=3): display(dibf,dibp); fin_del_ejemplo; fin_del_ejemplo 20

22 Cuarto ejemplo: Interpolación de Hermite de primer orden Las funciones de base Hermite de primer orden sobre un soporte de (n+1) puntos pueden calcularse a partir de los polinomios de base de Lagrange sobre el mismo soporte utilizando las expresiones: ( ) p (x) = 1 2 (x s ) L' (s ) L (x) (i = 0,1,...,n) (0) 2 i i i i i p (x) = (x s ) L (x) (i = 0,1,...,n) (1) 2 i i i donde: x s n j L i(x) = (i = 0,1,...,n) j= 0si sj j i (Recuerda que en la práctica anterior se escribieron procedimientos para el cálculo de los polinomios de base de Lagrange. En concreto blagrange permitía calcular todos los polinomios de base). Con dichos polinomios de base de Hermite, el polinomio interpolador de Hermite se podía expresar mediante la fórmula: n n (0) (1) i i i i i= 0 i= 0 p(x) = f(s) p (x) + f'(s) p (x) En este ejercicio desarrollaremos algunos procedimientos para calcular los polinomios interpoladores de Hermite de primer orden. El primero de tales procedimientos se recoge a continuación y evalúa los polinomios de base de Hermite correspondientes a un punto de soporte. El segundo, utilizando este procedimiento, calcula todos los polinomios de base de Hermite sobre un soporte dado. Para ello, además se utiliza el procedimiento polgri que permitía calcular un polinomio de base de Lagrange y que, por si no lo tuvieras grabado en disco, también lo incluimos aquí. 21

23 Cálculo de los polinomios de base de Hermite restart; polgri:=proc(n,s,i,g) g:=x-mul((x-s[k])/(s[i]- s[k]),k=0..i-1)*mul((x-s[k])/(s[i]-s[k]),k=i+1..n): end: polheri:=proc(n,s,i,g,g1) local L: polgri(n,s,i,l): g:=x-(1-2*(x- s[i])* (subs({y=s[i]},diff(l(y),y))))* L(x)*L(x): g1:=x-(x-s[i])*l(x)*l(x): end proc: bhermite:=proc(n,s,p,p1) local i: for i from 0 to n by 1 do polheri(n,s,i,p[i],p1[i]): end proc: save polgri,polheri, bhermite,"bhermite.m": fin_de_los_procedimientos; fin_de_los_procedimientos El siguiente procedimiento, utilizando los polinomios de base de Hermitee, calcula el polinomio interpolador de Hermite de una función f(x) dada Cálculo del polinomio interpolador de Hermite de primer orden. phermite:=proc(n,f,s,p) local H,H1, v, v1, i: read "bhermite.m"; H:=array(0..n): H1:=array(0..n): v:=array(0..n): v1:=array(0..n): bhermite(n, s, H, H1): for i from 0 to n by 1 do v[i]:=evalf(f(s[i])): v1[i]:=evalf(d(f)(s[i])): p:=x-sum((v[j]*h[j](x))+(v1[j]*h1[j](x)),j=0..n): end proc: 22

24 save phermite,"phermite.m": fin_del_procedimiento; fin_del_procedimiento Utilicemos los procedimientos anteriores para calcular el polinomio interpolador de Hermite de una función. Se desea realizar una interpolación de Hermite de primer orden de la función f(x) = sen(π x 2 ) con un soporte equidistante de 9 puntos en el intervalo [0, 2:π]. restart; with(linalg):with(plots): Warning, the protected names norm and trace have been redefined and unprotected Warning, the name changecoords has been redefined Leamos los ficheros con los procedimientos a utilizar: read ("phermite.m"); read ("bhermite.m"); read ("soporte.m"); Trabajaremos con 20 dígitos de precisión, y se introducen los datos Digits:=20: f := x- sin(pi*x^2); f := x sin( π x 2 ) n :=8: a:=0.: b:=evalf(2.*pi): s:=array(0..n): Calculemos el soporte soporte(a,b,n,s): print(s); 23

25 array( 0.. 8, [ ( 0) = 0. ( 1 ) = ( 2 ) = ( 3 ) = ( 4 ) = ( 5 ) = ( 6 ) = ( 7 ) = ( 8 ) = ]) Calculemos los polinomios ide base de Hermite bhermite(n,s,h,h1): Si quieres ver dos de ellos: expand(h1[1](x));expand(h[2](x)); x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x 4 Calculemos ya el polinomio interpolador de Hermite y dibujémoslo: 24

26 phermite(n,f,s,p); x 8 j = 0 ( v j H j ( x) + v1 j H1 j ( x )) expand(p(x)); x x x x x x x x x x x x x x x x 2 dibp:=plot(p(x),x=a..b,-8..8,color=red): dibf:=plot(f(x),x=a..b,-8..8,color=blue): ley1 := textplot([0.5,2,`polinomio`],color=red): ley2 := textplot([0.5,4,`función`],color=blue): display(dibf,dibp,ley1,ley2); Observa como, a pesar de coincidir lsobre los puntos del soporte los valores de la función y del polinomio, así como los de sus primeras derivadas, al ser un polinomio de grado elevado hay muy poca concordancia entre el polinomio 25

27 interpolador y la función f(x). Podemos representar el error de interpolación obteniendo: err := x-(f(x)-p(x)); err := x f( x ) p( x ) plot(err(x),x=0..2*pi); Como puedes ver el error cometido en el proceso de interpolación es muy alto. Ello se debe a que la función que estamos interpolando es muy oscilante y las técnicas de interpolación que estamos utilizando no permiten cazar con tan pocos puntos sus oscilaciones. Ante este tipo de funciones deberíamos: a) O incluir más puntos de soporte, distribuyéndolos de forma que hubiese más densidad de puntos en las zonas más oscilantes. b) o, interpolar por tramos, definiendo un mayor número de tramos en las zonas con oscilaciones más frecuentes. De este tipo de interpolación por tramos nos ocuparemos en la práctica siguiente. No obstante, para no dejarte con un mal sabor de boca volvamos a calcular (sin escribir resultados intermedios) el proceso anterior pero aplicado ahora a la función: f:=x-exp(x)*x^2; f := x e x x 2 26

28 AL ser la función más suave se tiene: n :=8: a:=0.: b:=evalf(2.*pi): s:=array(0..n): soporte(a,b,n,s): phermite(n,f,s,p): dibp:=plot(p(x),x=a..b,color=red): dibf:=plot(f(x),x=a..b,color=blue): ley1 := textplot([0.5,3000,`polinomio`],color=red): ley2 := textplot([0.5,7000,`función`],color=blue): display(dibf,dibp,ley1,ley2); Como puedes observer ahora el polinomio interpolador de Hermite y la función que se interpolan prácticamente coinciden en el intervalo en el que se ha considerado el soporte equidistante. Los errores, como muetra la gráfica siguiente són del orden de

29 err := x-(f(x)-p(x)): plot(err(x),x=0..2*pi); fin; fin 28

30 EJERCICIOS Primer ejercicio propuesto: Diferencias divididas con soporte de Chebyshev Realiza el primero de los ejemplos de esta práctica utilizando un soporte de Chebyshev (consúltese el primero de los ejercicios de la práctica nº 6 para ver los detalles sobre la obtención de este tipo de soportes). restart; fin; fin Segundo ejercicio propuesto: Interpolación de Hermite Calcula el polinomio interpolador de Hermite p(x) de la función f(x) = sen(5 x) sobre un soporte formado por 3 puntos {s 0, s 1, s 2 } verificándose las siguientes condiciones: p(s 0 ) = f(s 0 ), p (s 0 ) = f (s 0 ), p (s 0 ) = f (s 0 ) p(s 1 ) = f(s 1 ), p (s 1 ) = f (s 1 ) p(s 2 ) = f(s 2 ) Toma como puntos de soporte para verificar el programa MAPLE que realices: s 0 = 0, s 1 = π/2, s 2 = π 29

31 Representa la función interpoladora junto al polinomio interpolador. Asimismo realiza un gráfico conel error de interpolación cometido. restart; fin; 30