Curso03 04

Programación y Métodos Numéricos Examen de Laboratorio
Carlos Conde, Arturo Hidalgo, Alfredo López Curso 2003- 2004

Universidad Politécnica de Madrid – ETSI Minas – Depto. Matemática Aplic. y Méts. Informát.
UNIVERSIDAD POLITÉCNICA DE MADRID
E.T.S.I. MINAS
DEPARTAMENTO DE MATEMÁTICA APLICADA

Y MÉTODOS INFORMÁTICOS
Asignatura: PROGRAMACIÓN Y MÉTODOS NUMÉRICOS
Examen de Laboratorio (Grupo 3º - Jueves de 16h a 18h)

Fecha: 1 – VI – 2004
INSTRUCCIONES Y RECOMENDACIONES
1ª. El presente examen debe realizarse individualmente. Para la resolución de los
ejercicios que se proponen puede utilizarse toda la documentación (impresa o
informática) que se desee.
2ª. Al finalizar el examen debe entregarse un disquette etiquetado en el que se graben

los ejercicios resueltos. En la etiqueta debe figurar el nombre del alumno y el grupo de
Laboratorio al que pertenece (Grupo 5º) y la fecha de hoy.
3ª. Al fichero en el que se grabe la solución del examen debe asignársele un nombre
formado de la siguiente manera: el primer carácter será la inicial del primer nombre
propio del alumno. Tras él se escribirá el primer apellido del alumno (en el caso de ser
compuesto escríbase todo junto) seguido de la inicial del segundo apellido. Todas las
letras del nombre del fichero se escribirán en mayúsculas.
Ejemplo: Una alumna que se llamase EVA MARÍA LÓPEZ-GÓMEZ HEREDIA debe
asignar al fichero el nombre ELOPEZGOMEZH.
4ª. En el fichero escribe como primera línea tu nombre y apellidos completos. Además
identifica claramente el comienzo y el final de cada uno de los ejercicios.
5ª. Se recomienda grabar periódicamente (cada 5 minutos) para evitar perder el trabajo
realizado por bloqueos del ordenador. Asimismo se recomienda no abrir
simultáneamente muchas hojas de MAPLE pues ello puede ralentizar el funcionamiento
del ordenador llegando incluso a bloquearlo.
6ª. Se recomienda grabar eliminando las respuestas que proporciona MAPLE a las
instrucciones. Ello hará que la grabación sea más rápida al ocuparse menos memoria.
Recuerda que para eliminar las respuestas de MAPLE puedes seleccionar en la barra de
menús de MAPLE la opción “Edit” y en la ventana que se despliegue elegir la opción
“Remove_Output” seleccionando en la nueva ventana que se despliegue la opción
“FromWorksheet”. Si tienes problemas para realizar esta opción pide ayuda al profesor.
7ª. Lee con atención los enunciados de los ejercicios. Si tienes dudas en la comprensión
de los mismos no dudes en solicitar las aclaraciones oportunas al profesor.
Primer ejercicio (2.5 puntos)

Dada una función real f(x), derivable en un cierto intervalo [a,b] de , su
derivada primera en un punto x* de [a,b] se puede aproximar mediante la
fórmula:
f ( x1 ) − f ( x0 )
f ' ( x *) =
x1 − x0
siendo x0 y x1 dos puntos, en principio cualesquiera de [a,b]. Si dividimos [a,b]

mediante una serie de puntos equidistantes x0 = a < x1 < x2 < … < xN = b , es
posible aproximar f ' ( xi ) (i = 0, 1, …, N-1) mediante:
f ( xi +1 ) − f ( xi )
f ' ( xi ) = , i = 0,1,… , N − 1
h
b−a
con h = .
N
x
Se considera la función: f ( x ) = cos( ) ⋅ sin ( 2 x ) y el intervalo [ −π , π ] y se
2
pide escribir un programa MAPLE que:
a) Calcule, mediante la fórmula dada, f ' ( xi ) (i = 0, 1, …, N-1), para N=50,

y almacene el resultado en un vector df.
b) Represente en una gráfica conjuntamente f(x) y df, es decir, la función y

su derivada primera aproximada.
Solución:
Determinar numericamente la derivada de la función f(x) = cos(x/2)*sin(2x).
> restart:
> with(plots):
Warning, the name changecoords has been redefined
Declaramos la función f
> f:=x->cos(x/2)*sin(2*x);
f := x → cos⎜⎜⎛ x ⎟⎟⎞ sin( 2 x )
1
⎝2 ⎠
Establecemos los valores extremos del intervalo [a,b], el número de
subintervalos (N) y el tamaño de los subintervalos (h)
1
> a:=evalf(-Pi); b:=evalf(Pi); N:=50; h:=(b-a)/N;

a := -3.141592654
b := 3.141592654
N := 50
h := 0.1256637062
Declaramos los arrays x (puntos dosnde aproximamos la derivada de f) y df

(derivadas aproximadas de f)
> x:=array(0..N,[]): df:=array(0..N,[]):x[0]:=a:
Calculamos las derivadas aproximadas df[i] en cada punto x[i] (i = 0, 1, ...,

N-1)
> for i from 0 to N-1 do

x[i+1]:=x[i]+h;
df[i]:=evalf((f(x[i+1])-f(x[i]))/h):
od:
Dibujamos los resultados. Creamos una secuencia, ptos, para el dibujo,

dib1, de las derivadas aproximadas
> ptos:=[seq([x[i],df[i]], i=0..N)]:

> dib1:=plot(ptos,color=blue,thickness=2,
legend="derivada"):
Creamos el dibujo, dib2, de la función f(x)
> dib2:=plot(f,-Pi..Pi, thickness=2,color=black,

legend="función"):
Representamos conjuntamente dib1 y dib2
> display(dib1,dib2);
2
> fin_del_ejercicio;
fin_del_ejercicio
3
Segundo ejercicio (2.5 puntos)

Un grafo es un conjunto de puntos (ni, i = 1, 2, …, N) llamados nodos unidos
mediante segmentos (lj, j = 1, 2, …, M) llamados arcos. Por ejemplo:
1
2
1 4 5 5
2 4
6
3 3
El grafo de la figura precedente consta de 5 nodos (numerados del 1 al 5) y 6

arcos (numerados del 1 al 6).
La forma habitual de representar un grafo es mediante su matriz de incidencia,

A, en donde las columnas representan los arcos y las filas los nodos, con la siguiente
notación:
ai , j = 1 si el arco j pasa por el nodo i

ai , j = 0 si el arco j no pasa por el nodo i
Así, la matriz de incidencia para el grafo del ejemplo es:
⎛1 1 0 0 0 0⎞
⎜ ⎟
⎜1 0 1 0 0 0⎟
A = ⎜0 0 1 1 0 1⎟
⎜ ⎟
⎜0 1 0 1 1 0⎟
⎜0 1 ⎟⎠
⎝ 0 0 0 1
Se denomina dendrita a un subgrafo que une todos los nodos del grafo pero que
no contiene bucles, por ejemplo:
1
2
1 4 5 5
3 3
4
Por tanto, el conjunto de arcos {1,2,3,5} es una dendrita del grafo ejemplo.
Existen varios algoritmos para determinar una dendrita de un grafo a partir de su

matriz de incidencia. Uno de los más utilizados, el BFS (breadth first search), es el
siguiente:
Dados la matriz de incidencia A, el número de nodos, NNOD y el

número de arcos, NARC
Se declaran los vectores STACK(NNOD), EXAM(NNOD),

DENDR(NNOD-1)
Desde I = 1 hasta NNOD con paso 1 hacer

STACK[I] = 0
EXAM[I] = 0
Terminar para I
I=1
J=1
V =1
EXAM[V] = 1
Mientras I < NNOD hacer

Desde K=1 hasta NARC con paso 1 hacer
Si A[V,K] ≠ 0:
Desde L=1 hasta NNOD con paso 1 hacer
Si A[L,K] ≠ 0 y EXAM[L] = 0 :
U=L
EXAM[U] = 1
DENDR[I] = K
I = I+1
STACK[I] = U
Fin condición
Terminar para L
Fin condición
Terminar para K
J = J+1
V = STACK[J]
Fin bucle condicional
Se pide:
5
a) Construir un programa MAPLE que responda al algoritmo dado.
b) Aplicarlo al ejemplo.
Solución:
Algoritmo BFS
> restart:
> with(linalg):
Warning, the protected names norm and trace have been redefined and
unprotected
> NNOD:=5: NARC:=6:

>
A:=matrix(NNOD,NARC,[[1,1,0,0,0,0],[1,0,1,0,0,0],[0,0,1,1,0
,1],[0,1,0,1,1,0],[0,0,0,0,1,1]]);
⎡1 1 0 0 0 0⎤
⎢ ⎥
⎢1 0 1 0 0 0⎥
⎢ ⎥
⎢ ⎥
A := ⎢0 0 1 1 0 1⎥
⎢ ⎥
⎢0 1 0 1 1 0⎥
⎢ ⎥
⎢ ⎥
⎢0 0 0 0 1 1⎥
⎣ ⎦
> EXAM:=vector(NNOD): STACK:=vector(NNOD):
DENDR:=vector(NNOD-1):
> for i from 1 to NNOD do
STACK[i]:=0:
EXAM[i]:=0:
od:
> i:= 1:
> j:= 1:
> v:=1:
> EXAM[v]:= 1:
> while i < NNOD do
for k from 1 to NARC by 1 do
if A[v,k] <> 0 then
for l from 1 to NNOD by 1 do
if A[l,k]<>0 and EXAM[l]=0 then
u:=l:
EXAM[u]:=1:
DENDR[i]:=k:
i:=i+1:
STACK[i]:=u:
fi:
od:
fi:
od:
j:=j+1:
v:=STACK[j]:
6
od:
>
> print(DENDR);
[ 1, 2, 3, 5 ]
fin_del_ejercicio
Tercer ejercicio (5 puntos)
Dada una matriz cuadrada A de dimensión n, los coeficientes ai de su polinomio

característico:
det( A − λ I )
pueden determinarse por el método de Leverrier modificado:
an = (−1) n +1 B=A
an −1 = (−1) n tr (B) B = ( B − tr (B)I ) A
1 ⎛ tr (B) ⎞
an − 2 = (−1) n tr (B) B = ⎜B − I⎟A
2 ⎝ 2 ⎠
1 ⎛ tr (B) ⎞
an −3 = (−1) n tr (B) B = ⎜B − I⎟A
3 ⎝ 3 ⎠
1 ⎛ tr (B) ⎞
an −i = (−1) n tr (B) B = ⎜B − I⎟A
i ⎝ i ⎠
Por otra parte, las raíces del polinomio de grado n:
p( x) = a0 + a1 x + a2 x 2 + … + an x n
pueden calcularse utilizando el algoritmo siguiente:
7
Dados n, a(n), maxiter y eps

Declarar los vectores e(n) y q(n)
q[0] = -a[n-1]/a[n]
e[0] = e[n] = 0
Desde i = 1 hasta n-1 hacer

q[i] = 0
e[i] = a[n-i-1]/a[n-i]
Terminar para i
norma = 2*eps
iter = 1
Mientras norma > eps e iter < maxiter hacer
Desde i = 0 hasta i = n-1 hacer

q[i] = q[i] + e[i+1] – e[i]
Terminar para i
Desde i = 1 hasta i = n-1 hacer

e[i] = q[i]*e[i]/q[i-1]
Terminar para i
iter = iter + 1
n
norma = ∑ e [ j ]
j =0
Fin de bucle condicional

denominado algoritmo DC (diferencia de cocientes).
Se pide:
a) Construir un procedimiento MAPLE llamado Leverrier que, utilizando como

variables de entrada:
n Dimensión de la matriz
A Matriz
8
y de salida:
a Vector con los coeficientes del polinomio característico
calcule los coeficientes del polinomio característico de la matriz A.
b) Construir un procedimiento MAPLE llamado DC que, utilizando como variables

de entrada:
n Grado del polinomio

a Vector con los coeficientes del polinomio
y de salida:
q Vector con las raíces del polinomio
determine las raíces de un polinomio de grado n.
c) Construir un programa MAPLE que, utilizando los procedimientos construidos en

a) y b), permita obtener los valores propios de una matriz cuadrada y aplicarlo a la
matriz:
⎛ 4 2 −2 ⎞
⎜ ⎟
A = ⎜ −5 3 2 ⎟
⎜ −2 4 1 ⎟
⎝ ⎠
Solución:
Determinación de valores propios de una matriz cuadrada utilizando

conjuntamente los métodos DC y de Leverrier modificado
> restart:
> with(linalg): with(plots):
unprotected
Procedimiento DC
> DC:=proc(n,a,q)
description "calcula las raíces, x[i], i=0,1,...,n-1,
de un polinomio de grado n y coeficientes a[i]
i=0,1,...,n";
local i,j,iter,e,eps,maxiter,norma:
e:=array(0..n,[]):
9
eps:=1e-10; maxiter:=100;
q[0]:=evalf(-a[n-1]/a[n]);
e[0]:=0.; e[n]:=0.;
for i from 1 to n-1 do
q[i]:=0.;
e[i]:=evalf(a[n-i-1]/a[n-i]);
od;
norma:=2*eps; iter:=1;
while norma > eps and iter < maxiter do
q[i]:=q[i]+e[i+1]-e[i];
od;
e[i]:=q[i]*e[i]/q[i-1];
od;
iter:=iter+1:
norma:=sum(abs(e[j]),j=0..n);
od;
end proc:
Procedimiento Leverrier
> Leverrier:=proc(n,A,a)
description "calcula los coeficientes a[i] del
polinomio característico de la matriz A de dimensión n";
local B,In,aux,i,j;
B:=matrix(n,n): In:=matrix(n,n):
for i from 1 to n do
for j from 1 to n do
if i=j then
In[i,j]:=1:
else
In[i,j]:=0:
fi;
od;
od;
a[n]:=((-1)^(n+1));
B:=evalm(A):
for i from n-1 to 0 by -1 do

aux:=trace(B)/(n-i);
a[i]:=evalf(((-1)^n)*aux);
B:=evalm((B-aux*In)&*A):
od:
end proc:
>
10
> n:=3:
> a:=array(0..n,[]): x:=array(0..n-1,[]):
> A:= matrix(n,n,[[4,2,-2],[-5,3,2],[-2,4,1]]);
⎡ 4 2 -2⎤
⎢ ⎥
A := ⎢⎢-5 3 2⎥⎥
⎢⎢ ⎥⎥
⎣-2 4 1⎦
>
> Leverrier(n,A,a):
> DC(n,a,x):
> print(a,x);
array(0 .. 3, [ ]), array(0 .. 2, [
( 0 ) = -10. ( 0 ) = 5.000000001
( 1 ) = 17. ( 1 ) = 2.000000000
( 2 ) = -8. ( 2 ) = 0.9999999996
(3) = 1 ])
fin_del_ejercicio
11
Examen de Laboratorio (Grupo 4º)

Fecha: 2 – VI – 2004
Primer ejercicio (2’5 Puntos)
El modelo depredador-presa de Lotka y Volterra simula la evolución de la
población de una especie depredadora (por ejemplo, zorros) y una especie
presa (por ejemplo, conejos) en un ecosistema ideal (cerrado, en el que sólo
existan estas dos especies y en el que haya alimento suficiente para la especie
presa). Dicho modelo se expresa por el sistema diferencial:
⎧z '(t)⎫ ⎫
⎨ ⎬ = f(z(t),c(t)⎬ t>0
⎩c '(t)⎭ ⎭
z(0) = z0 , c(0) = c0
donde z(t) es la población de depredadores en el instante t, c(t) la población de

presas en el instante t, z0 y c0 son las poblaciones iniciales que se suponen
conocidas y f(z(t),c(t)) es una función vectorial de dos componentes y
dependientes de dos variables (las poblaciones de depredadores y presas).
Una forma (aproximada) de conocer la evolución de la población en el

periodo (0 , T) consiste en tomar (NP+1) instantes ti en dicho periodo y estimar
por el método de Runge - Kutta las poblaciones existentes en el instante ti+1 a
partir de las existentes en el instante ti. Más concretamente, partiendo de:
t0 = 0, z0 conocido y c0 conocido
se genera:
ti+1 = ti + h (i = 0, 1, ...., NP-1)
⎧ ⎫
⎪K = f (z , c ) ⎪
⎪ 0 i i ⎪
⎪ K1 = f ( zi + (h / 2) K 0 , ci + (h / 2) K 0 ) ⎪
⎪⎪ ⎪⎪
⎨ K 2 = f ( zi + (h / 4) K 0 + (h / 4) K1 , ci + (h / 4) K 0 + (h / 4) K1 ) ⎬ (i = 0,1,...,NP − 1)
⎪ ⎪
⎪ K 3 = f ( zi − hK1 + 2hK 2 , ci − hK1 + 2hK 2 ) ⎪
⎪⎧ zi +1 ⎫ ⎧ zi ⎫ ⎪
⎪⎨ ⎬ = ⎨ ⎬ + (h / 6)( K 0 + 4 K 2 + K 3 ) ⎪
⎩⎪⎩ ci +1 ⎭ ⎩ci ⎭ ⎭⎪
siendo h = T / NP, y f1(z, c) y f2(z, c) las dos componentes de la función

vectorial f(z(t),c(t)) .
12
Se pide que calcules según el esquema anterior la evolución de una

población de zorros y conejos en un ecosistema ideal en el que inicialmente
haya 4 zorros y 20 conejos (z0 = 4, c0 = 20), tomando NP = 5000 y T = 25.0 y
sabiendo que la función que rige el equilibrio entre ambas especies está dada
por la expresión:
⎧−0.16 ⋅ z + 0.03 ⋅ z ⋅ c ⎫
f(z,c) = ⎨ ⎬
⎩ 4.5 ⋅ c − 0.9 ⋅ z ⋅ c ⎭
Una vez calculados los valores de cada población en los instantes ti,
deberá representarse en una misma gráfica las dos secuencias de puntos (ti, zi)
y (ti, ci).
Solución:
> restart:
> with(plots):
> f:=(z,c)->vector(2,[-0.16*z+0.03*z*c,4.5*c-0.9*z*c]);
f := ( z, c ) → vector ( 2, [ −0.16 z + 0.03 z c, 4.5 c − 0.9 z c ] )
> np:=5000; T:=25.;
np := 5000
T := 25.
> z:=array(0..np):
c:=array(0..np):
t:=array(0..np):
k0:=vector(2,[]):
k1:=vector(2,[]):
k2:=vector(2,[]):
k3:=vector(2,[]):
t[0]:=0.:
z[0]:=4.:
c[0]:=20.:
> h:=T/np:
for i from 0 to (np-1) by 1 do
k0:=f(z[i],c[i]):
k1:=f(z[i]+(h/2)*k0[1],c[i]+(h/2)*k0[2]):
k2:=f(z[i]+(h/4)*k0[1]+(h/4)*k1[1],c[i]+(h/4)*k0[2]+(h/4)*k
1[2]):
k3:=f(z[i]-h*k1[1]+2*h*k2[1],c[i]-h*k1[2]+2*h*k2[2]):
t[i+1]:=i*h:
z[i+1]:=z[i]+(h/6)*(k0[1]+4*k2[1]+k3[1]):
c[i+1]:=c[i]+(h/6)*(k0[2]+4*k2[2]+k3[2]):
od:
13
> zorros:=[seq([t[k],z[k]],k=0..np)]:
conejos:=[seq([t[k],c[k]],k=0..np)]:
>
dzorros:=pointplot(zorros,symbol=box,color=red,connect=true
):
dconejos:=pointplot(conejos,symbol=circle,color=blue,connec
t=true):
>
display(dzorros,dconejos,labels=[`tiempo`,`unidades`],label
directions=[HORIZONTAL,VERTICAL]);
> fin_ejercicio_primero;
fin_ejercicio_primero
Segundo ejercicio (2’5 Puntos)

El método de Newton-Raphson para el cálculo de raíces de ecuaciones no
lineales consiste, básicamente, en: Dado un valor de x0 se genera la sucesión:
∞
⎧⎪ f ( x i ) ⎫⎪
⎨ x i+1 = x i - ⎬
⎩⎪ f ′ ( x )
i ⎭⎪i=0
14
En ocasiones, evaluar la derivada en cada iteración es “problemático”

(valores nulos o muy pequeños, coste de cálculo, ...) En esos casos puede
adoptarse una estrategia diferente después de la segunda iteración, dando
lugar así al llamado método de la secante.
En este ejercicio se pide que escribas un programa MAPLE para obtener

una raíz de una ecuación no lineal mediante el método de la secante. Para ello,
utilizando la notación empleada anteriormente, debes seguir el siguiente
algoritmo:
ALGORITMO
Dada la función f(x) Determinar f’(x)
Dados: x, maxiter y ε
f (x)
y← x- jÅ1
f′( x )
MIENTRAS ( ( j < maxiter) Y ( | x – y | > ε ) ) HACER:
x.f(y) - y.f(x)
1º) z ← 2º) x Å y
f(y) - f(x)
3º) y Å z 4º) j Å j+1
FIN BUCLE CONDICIONAL
Utiliza el programa anterior para calcular las raíces de la función :
f ( x) = x3 − 2 x − 5
en el intervalo [2,3].
Solución
> secante:=proc(xinic,maxiter,eps,f,z,tol,iter)
local aux,x,y,j:
x:=xinic:
y:= x-f(x)/D(f)(x):
j:= 1:
while ((j<maxiter) and (abs(x-y)>eps)) do
15
aux:=(x*f(y)-y*f(x))/(f(y)-f(x)):
x:= y:
y:= aux:
j:= j+1:
od:
z:=aux:
tol:=abs(x-y):
iter:=j:
end:
> save secante,"C:/secante.m":
> restart;
> read "C:/secante.m":
> maxiter:=20; eps:=10.^(-4); f:=x->x^3-2.*x-5.; x:=3.;
maxiter := 20
eps := 0.0001000000000
f := x → x3 − 2. x − 5.
x := 3.
> secante(x,maxiter,eps,f,sol,tol,iter):
> evalf(sol);tol;iter;
2.094551484
0.3907 10-5
6
>
Tercer ejercicio (5 Puntos)

Si se quiere calcular los valores propios de una matriz cuadrada cualquiera, es
muy ventajoso reemplazarla por una matriz reducida semejante, aplicándole a
continuación un procedimiento de tipo iterativo a la matriz reducida. De estas
técnicas una de las mas interesantes es la de Hessenberg, que es el objeto de
este ejercicio. Se denomina matriz de Hessenberg (superior) a toda matriz
A = (aij )1≤i , j ≤ n para la cual aij = 0 para todo i y j tales que 1<=j<=i-2<=n-2.
16
Sean p y q dos enteros tales que 1<=p<q<=n. Tomaremos n=5, p=2 y q=4 para
visualizar los cálculos y razonaremos en el caso general.
1. Definir una matriz cuadrada A de orden n, de elementos aij .

2. Definir la matriz T = (tij )1≤i , j ≤ n tal que t pp = 0 , t pq = 1 , tqq = 0 , tqp = 1 y
tij = δ ij (símbolo de Kroneker) en todos los demás casos.
3. Definir las matriz S = ( sij )1≤i , j ≤ n tal que sqp = α (dato real o complejo) y
sij = δ ij en todos los demás casos.
4. Definir una función Pivote, de argumentos A, k, y n que busque l tal que:
alk = max aik
k +1≤ i ≤ n
y devuelve una lista constituida por el elemento alk (llamado pivote) y el

inicie l.
5. Escribir una función Permutación, de argumentos A, i, y j que permute
en A las filas de índices i,j y las columnas de índices i,j.
6. Escribir una función Reducción, de argumentos A, k, pivote, l, n que para
i = k+2,....,n calcule:
a
α = ik
pivote
y sustraiga de la fila de índice i la fila de índice k+1 multiplicada por α . Esta
función deberá, además, para cada valor de i, sumar a la columna de índice
k+1 la columna de índice i multiplicada por α . Esta función Reducción
devolverá la matriz reducida, en la que los elementos de aik (i=k+2,...n) han
sido anulados.
7. Utilizando las tres funciones que vienen de ser definidas, escribir un
procedimiento Hessenberg, de argumento A, que proporcione una matriz
de Hessenberg similar a A.
8. Aplicarlo a una matriz real cuadrada de orden 6 cuyos elementos sean
generados al azar entre –10 y 10 y expresados con 7 cifras.
Solución:
> restart:with(linalg):
>
Warning, the protected names norm and trace have been redefined and unprotected
> n:=5: f:=(i,j)->a[i,j]: A:=matrix(n,n,f);
17
⎡a 1, 1 a 1, 2 a 1, 3 a 1, 4 a 1, 5⎤
⎢ ⎥
⎢a a 2, 5⎥⎥
⎢ 2, 1 a 2, 2 a 2, 3 a 2, 4
⎢ ⎥
⎢ a 3, 5⎥⎥
A := ⎢a 3, 1 a 3, 2 a 3, 3 a 3, 4
⎢ ⎥
⎢ ⎥
⎢a 4, 1 a 4, 2 a 4, 3 a 4, 4 a 4, 5⎥
⎢ ⎥
⎢ ⎥
⎢a 5, 1 a 5, 2 a 5, 3 a 5, 4 a 5, 5⎥
⎣ ⎦
> T:=diag(1$5):
> T[2,2]:=0: T[2,4]:=1: T[4,4]:=0: T[4,2]:=1:
> eval(T);
⎡1 0 0 0 0⎤
⎢ ⎥
⎢0 0 0 1 0⎥⎥
⎢
⎢0 0 1 0 0⎥⎥
⎢
⎢ ⎥
⎢0 1 0 0 0⎥⎥
⎢
⎢⎢ ⎥
⎣0 0 0 0 1⎥⎦
> evalm(T&*A):
> evalm(inverse(T)):
> evalm(A&*T):
> evalm(T&*A&*T):
> S:=diag(1$n): S[4,2]:=alpha: eval(S);
⎡1 0 0 0 0⎤
⎢ ⎥
⎢0 1 0 0 0⎥
⎢ ⎥
⎢0 0 1 0 0⎥
⎢ ⎥
⎢ ⎥
⎢0 α 0 1 0⎥
⎢ ⎥
⎢⎢ ⎥⎥
⎣0 0 0 0 1⎦
> evalm(S&*A):
> S1:=inverse(S): eval(S1):
> evalm(A&*S1):
> Pivot:=proc(A,k,n)
local pivot,l,i;
pivot:=A[k+1,k];
l:=k+1;
for i from k+2 to n do
if abs(pivot)<abs(A[i,k]) then pivot:=A[i,k];l:=i
fi
od;
[pivot,l]:
end:
> Permutation:=proc(A,i,j)
local B, linea;
B:=A;
to 2 do
B:=convert(B,listlist);
linea:=B[i];
B[i]:=B[j];
18
B[j]:=linea;
B:=transpose(B):
od;
B:
end:
> Reduction:=proc(A,k,pivot,n)
local B,alpha,i,j;
B:=A;
for i from k+2 to n do
alpha:=B[i,k]/pivot;
B[i,k]:=0;
for j from k+1 to n do
B[i,j]:=B[i,j]-alpha*B[k+1,j]:
od;
B:=addcol(B,i,k+1,alpha):
od;
B:
end:
> Hessenberg:=proc(A)
local B,pivot,l,n,k,p;
B:=A;
n:=rowdim(A);
for k to n-2 do
p:=Pivot(B,k,n);pivot:=p[1];l:=p[2];
if pivot<>0 then
B:=Permutation(B,k+1,l);
B:=Reduction(B,k,pivot,n);
fi
od;
eval(B):
end:
> A:=randmatrix(6,6,entries=rand(-10000000..10000000));
⎡ -449316 1443958 -1466708 -9494177 -190111 4944555⎤
⎢ ⎥
⎢ 6279651 -8515675 -6211942 -9972001 -7020144 8819815⎥
⎢ ⎥
⎢ 8355940 6969561 -4145631 -2085325 9530039 7360042⎥
⎢ ⎥
A := ⎢⎢ ⎥
⎥
⎢ -7909422 -5702248 -4713511 4626396 -9336645 -4582564⎥
⎢ ⎥
⎢ 3269370 -2814418 3506921 4734509 5731080 -5474758⎥
⎢ ⎥
⎢⎢ ⎥⎥
⎣ 9162767 -1757952 -5761588 8493037 -2818650 -8707130⎦
> A:=map(x->evalf(.1*10^(-5)*x),A);
19
A :=
[ -0.4493160000 , 1.443958000 , -1.466708000 , -9.494177000 , -0.1901110000 ,
4.944555000]
[ 6.279651000 , -8.515675000 , -6.211942000 , -9.972001000 , -7.020144000 ,
8.819815000]
[ 8.355940000 , 6.969561000 , -4.145631000 , -2.085325000 , 9.530039000 ,
7.360042000]
[ -7.909422000 , -5.702248000 , -4.713511000 , 4.626396000 , -9.336645000 ,
-4.582564000]
[ 3.269370000 , -2.814418000 , 3.506921000 , 4.734509000 , 5.731080000 ,
-5.474758000]
[ 9.162767000 , -1.757952000 , -5.761588000 , 8.493037000 , -2.818650000 ,
-8.707130000]
> C:=Hessenberg(A);
C :=
[ -0.4493160000 , 12.72427236 , -8.911858609 , -0.9668842518 , 1.495268666 ,
-0.1901110000]
[ 9.162767000 , -23.50320984 , 14.48178506 , -5.762057362 , -0.9972027037 ,
-2.818650000]
[ 0 , -40.40229103 , 24.45995437 , -9.650278755 , -4.043100487 , -11.76974106]
[ 0 , 0 , 5.608346896 , -6.918765544 , 1.805311832 , 1.90738667]
[ 0 , 0 , 0 , -6.039060437 , -8.469391351 , -11.38781222]
[ 0 , 0 , 0 , 0 , -6.145423282 , 3.420452362]
> eigenvalues(C);
>
-5.633057316 + 8.250334935 I, -5.633057316 − 8.250334935 I, 12.15749413,
-7.419387855, 7.847707629, -12.77997528
> eigenvalues(A);
>
-5.633057313 + 8.250334941 I, -5.633057313 − 8.250334941 I, 12.15749412,
-7.419387854, 7.847707630, -12.77997527
> eval(A);
20
[ -0.4493160000 , 1.443958000 , -1.466708000 , -9.494177000 , -0.1901110000 ,

4.944555000]
[ 6.279651000 , -8.515675000 , -6.211942000 , -9.972001000 , -7.020144000 ,
8.819815000]
[ 8.355940000 , 6.969561000 , -4.145631000 , -2.085325000 , 9.530039000 ,
7.360042000]
[ -7.909422000 , -5.702248000 , -4.713511000 , 4.626396000 , -9.336645000 ,
-4.582564000]
[ 3.269370000 , -2.814418000 , 3.506921000 , 4.734509000 , 5.731080000 ,
-5.474758000]
[ 9.162767000 , -1.757952000 , -5.761588000 , 8.493037000 , -2.818650000 ,
-8.707130000]
> Fin_ejercicio_3;
Fin_ejercicio_3
>
21

Fecha: 3 – VI – 2004
Primer ejercicio (2’5 puntos)
Considera los puntos (xi, yi) (i = 0, ..., n) definidos como sigue:
xi = ρi ·cos(θi ) , yi = ρi .sen(θi ) (i = 0, 1, ..., n)

donde
⎧⎪ 1
⎪⎪ ·V·t i si 0 ≤ t i ≤ TC
⎪ 2
ρi = ⎨
⎪⎪ 1 1
⎪⎪ ·V·TC − ·V·(t i − TC ) si TC < t i
⎪⎩ 2 3
y
⎧⎪ ω·t i si 0 ≤ t i ≤ TC
θi = ⎪⎨
⎪⎪⎩ω·(3·TC − t i ) / 2 si TC < t i
donde los instantes ti son (n+1) instantes uniformemente repartidos en un cierto
intervalo (0, Tf).
Se pide que escribas un programa MAPLE que calcule los puntos (xi, yi)
(i = 0, ..., n) definidos como se acaba de detallar y los representes en una
gráfica uniéndolos en color azul. Prueba el programa con los datos:
V = 25, ω = 2, Tc = 7, Tf = 12, n = 200.
Solución:
> restart;
> with(plots):
> V:=25;omega:=2;TC:=7;n:=200;TF:=12.;
x:=array(0..n):
y:=array(0..n):
V := 25
ω := 2
TC := 7
n := 200
TF := 12.
> h:=TF/n:
22
for i from 0 to 200 by 1 do

t:=i*h:
if (t <= TC) then
rho:=V*t/2:
theta:=omega*t:
else
rho:=(V*TC/2)-(V*(t-TC))/3:
theta:=omega*(3*TC-t)/2:
fi:
x[i]:=rho*cos(theta):
y[i]:=rho*sin(theta):
od:
> ptos:=[seq([x[i],y[i]],i=0..n)]:
> pointplot(ptos,color=blue,connect=true);
> fin_del_primer_ejercicio;
fin_del_primer_ejercicio

Programa en MAPLE el siguiente algoritmo que, utilizando el algoritmo de
Gram-Schmidt, permite obtener un conjunto de m vectores ortogonales de Rn
a partir de m vectores dados de dicho espacio. Los m vectores de partida se
consideraran dados como las m columnas de una matriz U y los m vectores
ortogonales calculados se consideran que forman las m columnas de una
23
matriz V. Con ello el algoritmo de Gram-Schmidt que se pide programar se

puede escribir como sigue:
ALGORITMO
Datos: n, m, matriz U de dimensiones (n, m)
Para i desde 1 hasta n con paso 1 hacer:

Vi,1 Å Ui,1
Fin bucle en i.
norma1 Å 0
norma1 Å norma1 +(Vi,1)2
Fin bucle en i.
Para i desde 2 hasta m con paso 1 hacer:
Para j desde 1 hasta (i-1) con paso 1 hacer:
algo Å 0
Para k desde 1 hasta n con paso 1 hacer:
algo Å algo + Uk,i · Vk,j
Fin bucle en k.
αi,j Å algo / normaj
Fin bucle en j.
normai Å 0
Para j desde 1 hasta n con paso 1 hacer:
Vj,i Å Uj,i
Para k desde 1 hasta (i-1) con paso 1 hacer:
Vj,i Å Vj,i – αi,k · Vj,k
Fin bucle en k.
normai Å normai + (Vj,i)2
Fin bucle en j.
Fin bucle en i.
Escribir la matriz V
FIN ALGORITMO
Utilícese el algoritmo anterior para n = 5, m = 3 y con la matriz U dada por:
24
⎡1 1 1⎤
⎢ ⎥
⎢1 0 0⎥
⎢ ⎥
U = ⎢⎢ 0 1 0 ⎥⎥
⎢0 0 1⎥⎥
⎢
⎢1 1⎥⎥⎦
⎢⎣ 1
Solución:
> restart;
> with(linalg):
unprotected
> n:=5;m:=3;
U:=matrix(n,m,[[1,1,1],[1,0,0],[0,1,0],[0,0,1],[1,1,1]]);V:
=matrix(n,m):
n := 5
m := 3
⎡1 1 1⎤
⎢ ⎥
⎢1 0 0⎥⎥
⎢
⎢ ⎥
U := ⎢⎢ 0 1 0⎥⎥
⎢0 1⎥⎥
⎢ 0
⎢ ⎥
⎢1 1⎥⎦
⎣ 1
> for i from 1 to n by 1 do
V[i,1]:=U[i,1]:
od:
> normj[1]:=0:
for i from 1 to n by 1 do
normj[1]:=normj[1]+V[i,1]*V[i,1]:
od:
> for i from 2 to m by 1 do
for j from 1 to i-1 by 1 do
algo:= 0:
for k from 1 to n by 1 do
algo:=algo+U[k,i]*V[k,j]:
od:
alpha[i,j]:= algo/normj[j]:
od:
normj[i]:=0:
for j from 1 to n by 1 do
V[j,i]:=U[j,i]:
for k from 1 to i-1 by 1 do
V[j,i]:=V[j,i]-alpha[i,k]*V[j,k]:
od:
normj[i]:=normj[i]+V[j,i]**2:
od:
od:
25
> evalm(V);
⎡ 1 1 ⎤
⎢ 1 ⎥
⎢ 3 5 ⎥
⎢ ⎥
⎢ ⎥
⎢ -2 -2 ⎥
⎢ 1 ⎥
⎢ 3 5 ⎥
⎢ ⎥
⎢ ⎥
⎢ -2 ⎥
⎢ ⎥
⎢ 0 1 ⎥
⎢ 5 ⎥
⎢ ⎥
⎢ ⎥
⎢ 0 0 1 ⎥
⎢ ⎥
⎢ 1 1 ⎥
⎢ ⎥
⎢ 1 ⎥
⎣ 3 5 ⎦
Comprobación de la ortogonalidad de los vectores (no pedida en el enunciado)
> for iv from 1 to m by 1 do
for jv from 1 to m by 1 do
valor:= 0:
for k from 1 to n by 1 do
valor:=valor + V[k,iv]*V[k,jv]:
od:
print (iv,jv,valor);
od:
od;
1, 1, 3
1, 2, 0
1, 3, 0
2, 1, 0
5
2, 2,
3
2, 3, 0
3, 1, 0
3, 2, 0
7
3, 3,
5
> fin_del_segundo_ejercicio;
fin_del_segundo_ejercicio
26

Se pide:
a) Escribir un procedimiento MAPLE en el que dados el valor de dos puntos
distintos a y b, se calculen cuatro puntos {x1, x2, x3, x4} y de cuatro
coeficientes {c1, c2, c3, c4} definidos como se detalla a continuación:
⎛ a + b ⎞⎟ ⎛ b − a ⎟⎞ ⎛ ⎞
x1 = ⎜⎜ ⎟ − 0.8611363116· ⎜⎜ ⎟ , c = 0.3478548451·⎜⎜ b − a ⎟⎟
⎜⎝ 2 ⎠⎟ ⎝⎜ 2 ⎟⎠ 1 ⎜⎝ 2 ⎠⎟
⎛ a + b ⎞⎟ ⎛ b − a ⎞⎟ ⎛ b − a ⎞⎟
x 2 = ⎜⎜ ⎟ − 0.3399810436·⎜⎜ ⎟ , c 2 = 0.6521451548·⎜⎜
⎝⎜ 2 ⎠ ⎟ ⎝⎜ 2 ⎠ ⎟ ⎜⎝ 2 ⎠⎟⎟
⎛ a + b ⎞⎟ ⎛ b − a ⎞⎟
x 3 = ⎜⎜ ⎟ + 0.3399810436· ⎜⎜ ⎟ , c3 = c2
⎜⎝ 2 ⎠⎟ ⎝⎜ 2 ⎠⎟
⎛ a + b ⎞⎟ ⎛ b − a ⎞⎟
x 4 = ⎜⎜ ⎟
⎟ + 0.8611363116·⎜⎜ ⎟ , c4 = c1
⎝⎜ 2 ⎠ ⎝⎜ 2 ⎠⎟
Los puntos se calcularán como elementos de un vector x de cuatro
elementos y los coeficientes como elementos de un vector c de cuatro
elementos. El procedimiento se llamará pgauss4 y se salvará en un
fichero en disquete llamado “pgauss4.m”.
b) Escribir un procedimiento MAPLE en el que dados cuatro puntos {x1, x2,

x3, x4} y cuatro coeficientes {c1, c2, c3, c4} así como dos funciones f y g se
calcule el valor:
4
valor = ∑ c i ·f(xi )·g(xi )
i=1
El procedimiento se llamará pescfun y se salvará en un fichero en

disquete llamado “pescfun.m”.
c) Escribir un programa MAPLE en el que dadas las funciones:

f1(x) = 1 + x2, f2(x) = x + (x3 /3) , f3(x) = 1 + x + x2 + x3
y los valores a = 0 y b = 3:
1º) Utilice el procedimiento pgauss4 para calcular los cuatro puntos x y

pesos c correspondientes a los valores de a y b que se acaban de
proporcionar.
2º) Calcule las funciones g1(x), g2(x) y g3(x) definidas como sigue:
g1(x) = f1(x),
g2(x) = f2(x) – α2,1·g1(x) ,
g3(x) = f3(x) – α3,1·g1(x) – α3,2·g2(x)
27
donde los valores αi,j (i = 2, 3; j = 1,.. i-1) se calcularán con ayuda del
procedimiento pescfun ya que se corresponden a los valores :
4
αi,j = ∑ c ·f (x
k =1
k i k )·g j (xk )
siendo los puntos y pesos {xk} y {ck} (k = 1, .., 4) los calculados con el
procedimiento pgauss4.
3º) Dibuje las tres funciones g1(x), g2(x) y g3(x) en el intervalo [a, b]
mostrando las tres gráficas en un mismo dibujo y con diferentes colores.
(Valoración de cada apartado: a) 1 punto, b) 1’5 puntos, c) 2’5 puntos)
Solución:
a)
> restart;
> pgauss4:=proc(a,b,x,c)
x:=vector(4):
c:=vector(4):
x[1]:=((a+b)-0.8611363116*(b-a))/2.:
c[1]:=0.3478548451*(a+b)/2.:
x[2]:=((a+b)-0.3399810436*(b-a))/2.:
c[2]:=0.6521451548*(a+b)/2.: x[3]:=((a+b)+0.3399810436*(b-
a))/2.: c[3]:=c[2]:
x[4]:=((a+b)+0.8611363116*(b-a))/2.: c[4]:=c[1]:
end proc:
> save pgauss4, "pgauss4.m":

> fin_del_primer_procedimiento;
fin_del_primer_procedimiento
b)
> pescfun:=proc(x,c,f,g,valor)
local resul, i:
resul:=0.:
resul:=resul+c[i]*f(x[i])*g(x[i]):
od:
valor:=resul:
end proc:
> save pescfun, "pesfunc.m":
> fin_del_segundo_procedimiento;
fin_del_segundo_procedimiento
28
c)
> restart;
> with(linalg):with(plots):
unprotected

> f[1]:=x-> 1+x*x;
f[2]:=x-> x+x*x*x/3;
f[3]:=x-> 1+x+x*x+x*x*x;
f 1 := x → 1 + x x
1
f 2 := x → x + x x x
3
f 3 := x → 1 + x + x x + x x x
> a:=0;b:=3;m:=3;
a := 0
b := 3
m := 3
> read "pgauss4.m":
read "pesfunc.m":
> pgauss4(a,b,x,c):
> g[1]:=f[1];
g1 := f 1
> pescfun(x,c,g[1],g[1],norma[1]):
for j from 1 to (i-1) by 1 do
pescfun(x,c,f[i],g[j],algo[i,j]):
alpha[i,j]:= algo[i,j]/norma[j]:
od:
g[i]:=f[i]:
g[i]:=g[i]-alpha[i,j]*g[j]:
od:
pescfun(x,c,g[i],g[i],norma[i]):
od:
> vv:=matrix(m,m):
for j from 1 to m by 1 do
pescfun(x,c,f[i],g[j],valor[i,j]):
vv[i,j]:=valor[i,j]:
od:
od:
29
> dib1:=plot(g[1](x),x=a..b,color=blue):
dib2:=plot(g[2](x),x=a..b,color=red):
dib3:=plot(g[3](x),x=a..b,color=gold):
> display(dib1,dib2,dib3);
> fin_del_tercer_ejercicio;
fin_del_tercer_ejercicio
30

Fecha: 3 – VI – 2004
Primer ejercicio (2’5 puntos)
Considera los puntos (xi, yi) (i = 0, ..., n) definidos como sigue:
xi = ρi ·cos(θi ) , yi = ρi .sen(θi ) (i = 0, 1, ..., n)

donde
⎧⎪ 1
⎪⎪ R − ·V·t i si 0 ≤ t i ≤ TC
⎪ 2
ρi = ⎨
⎪⎪ 1
⎪⎪V·(t i − TC ) + ·a·(t i − TC ) TC < ti
2
si
⎪⎩ 2
y θi = ω·t i
donde los instantes ti son (n+1) instantes uniformemente repartidos en un cierto
intervalo (0, Tf) y Tc = 2R/V.
Se pide que escribas un programa MAPLE que calcule los puntos (xi, yi) (i = 0,
..., n) definidos como se acaba de detallar y los representes en una gráfica
uniéndolos en color azul. Prueba el programa con los datos:
R = 25, V = 2, ω = 1, a = 0.05, Tf = 50, n = 800.
Solución:
> restart;
> with(plots):
> R:=25;V:=2;omega:=1;a:=0.05;
n:=800;TF:=50.;
x:=array(0..n):
y:=array(0..n):
R := 25
V := 2
ω := 1
a := 0.05
n := 800
TF := 50.
31
> h:=TF/n:
TC:=2*R/V:
t:=i*h:
if (t <= TC) then
rho:=R-V*t/2:
theta:=omega*t:
else
rho:=V*(t-TC)+a*(t-TC)*(t-TC)/2.:
theta:=omega*t:
fi:
y[i]:=rho*sin(theta):
od:
> ptos:=[seq([x[i],y[i]],i=0..800)]:
> pointplot(ptos,color=blue,connect=true);

El algoritmo siguiente resuelve sistemas tridiagonales por el método de Gauss
en el caso de no necesitarse estrategias de pivotaje durante el proceso de
resolución. La notación que se sigue para la matriz del sistema y el vector de
segundos términos se recoge a continuación:
32
⎡ d1 b1 0 0 ... 0 0 0 ⎤⎧ ⎪ x1 ⎪ ⎫ ⎪
⎧ c1 ⎪ ⎫
⎢ ⎥⎪ ⎪ ⎪
⎪ ⎪
⎪ ⎪
⎪
⎢a 2 d2 b2 0 ... 0 0 0 ⎥⎪ x ⎪ ⎪ c ⎪
⎢ ⎥⎪ ⎪ 2 ⎪
⎪ ⎪
⎪ 2 ⎪
⎪
⎢0
⎢ a3 d3 b3 ... 0 0 0 ⎥⎥ ⎪ ⎪
⎪ x 3
⎪
⎪
⎪
⎪
⎪
⎪ c 3
⎪
⎪
⎪
⎢0 ⎪ ⎪ ⎪ ⎪
⎢ 0 a4 d4 ... 0 0 0 ⎥⎥ ⎪ ⎪ x 4 ⎪
⎪ ⎪
⎪ c 4 ⎪
⎪
⎢ ... ·⎥ ⎨ ⎬=⎨ ⎬
⎢ ... ... ... % ... ... ... ⎥ ⎪ ⎪ ... ⎪⎪ ⎪
⎪ ... ⎪⎪
⎢ ⎥⎪ ⎪ ⎪ ⎪
⎢0 0 0 0 ... dn−2 bn−2 0 ⎥ ⎪x n−2 ⎪ ⎪c n−2 ⎪
⎪ ⎪ ⎪ ⎪
⎢ ⎥⎪ ⎪ ⎪
⎪ ⎪
⎪ ⎪
⎪
⎢0 0 0 0 ... an−1 dn−1 bn−1 ⎥ ⎪ ⎪ x ⎪
n−1 ⎪
⎪
⎪ c ⎪
n−1 ⎪
⎢ ⎥⎪ ⎪ ⎪ ⎪
⎢⎣ 0 0 0 0 ... 0 an dn ⎥⎦ ⎪⎪
⎪⎩ x n ⎪
⎪ ⎪
⎪ ⎪
⎭ ⎪ cn ⎪
⎩
⎪
⎪
⎭
ALGORITMO
Datos: n, la matriz tridiagonal S (que forma la matriz del sistema) y el vector de
segundo término {ci}1<i<n
Salvar el vector c con el nombre corig.
Extraer de S los vectores {ai}2<i<n, {di}1<i<n, y {bi}1<i<n-1,
di Å di – (ai·bi-1 / di-1)
ci Å ci – (ai·ci-1 / di-1)
Fin bucle en i.
xn Å cn / dn.
Para i desde n-1 hasta 1 con paso -1 hacer:
xi Å (ci - bi·xi+1) / di
Fin bucle en i.
Escribir la solución (vector x)

Evaluar la norma-2 del error ||S·x – corig||2
FIN ALGORITMO
Utilícese el algoritmo anterior con n = 4, para el sistema:

⎡1 1 0 0⎤ ⎪ ⎧x ⎪ ⎫ ⎧1⎪ ⎫
⎢ ⎥ ⎪⎪ 1 ⎪⎪ ⎪
⎪⎪ ⎪⎪
⎢ 1 2 1 0 ⎥ ⎪x 2 ⎪ ⎪1⎪
⎢ ⎥·⎪ ⎪ ⎪⎪
⎬=⎨ ⎬
⎢0 1 3 1⎥ ⎨ ⎪ ⎪ ⎪ 1⎪
⎢ ⎥ ⎪x 3 ⎪ ⎪ ⎪
⎢0 0 1 4 ⎥ ⎪ ⎪ ⎪
⎪ ⎪ ⎪
⎣ ⎦⎩ x
⎪ 4⎭ ⎪ ⎩⎪ ⎭⎪
⎪1 ⎪
33
Solución:
> restart;
> with(linalg):
unprotected
> n:=4;
S:=matrix(n,n,[[1,1,0,0],[1,2,1,0],[0,1,3,1],[0,0,1,4]]);
c:=vector(n,[1,1,1,1]):
x:=vector(n):
n := 4
⎡1 1 0 0⎤
⎢ ⎥
⎢1 2 1 0⎥⎥
S := ⎢⎢ ⎥
⎢0 1 3 1⎥⎥
⎢
⎢0 4⎥⎦
⎣ 0 1
> corig:=vector(n):
corig:=evalm(c);
corig := [ 1, 1, 1, 1 ]
> a:=vector(n):d:=vector(n):b:=vector(n):
> d[1]:=S[1,1]:
a[1]:=0:
d[i]:=S[i,i]:
a[i]:=S[i,i-1]:
b[i-1]:=S[i-1,i]:
od:
b[n]:=0:
> evalm(a);evalm(b);evalm(d);
[ 0, 1, 1, 1 ]
[ 1, 1, 1, 0 ]
[ 1, 2, 3, 4 ]
d[i]:= d[i]-a[i]*b[i-1]/d[i-1]:
c[i]:= c[i]-a[i]*c[i-1]/d[i-1]:
od;
d2 := 1
c2 := 0
d3 := 2
c3 := 1
34
7
d4 :=
2
1
c4 :=
2
> x[n]:=c[n]/d[n];
for i from n-1 to 1 by -1 do
x[i]:=(c[i]-b[i]*x[i+1])/d[i]:
od;
1
x4 :=
7
3
x3 :=
7
-3
x2 :=
7
10
x1 :=
7
> evalm(x);
evalm(S&*x);
⎡ 10, -3, 3, 1 ⎤
⎢⎢ ⎥⎥
⎣ 7 7 7 7⎦
[ 1, 1, 1, 1 ]
> norm(S&*x-corig,2);
0

Se pide:
a) Escribir un procedimiento MAPLE en el que dados el valor de dos puntos
distintos a y b, se calculen tres puntos {x1, x2, x3} y de tres coeficientes
{c1, c2, c3} definidos como se detalla a continuación:
⎛ a + b ⎞⎟ 3 ⎛⎜ b − a ⎞⎟ ⎛ b − a ⎞⎟
x1 = ⎜⎜ ⎟ − ⎟ c1 = 5·⎜⎜
⎜⎝ 18 ⎠⎟⎟
⎟ ·⎜ ⎟ ,
⎝⎜ 2 ⎠ 5 ⎝⎜ 2 ⎠
⎛ a + b ⎞⎟ ⎛ b − a ⎞⎟
x 2 = ⎜⎜ ⎟ = ⎜⎜
⎜⎝ 18 ⎠⎟⎟
, c 8·
⎜⎝ 2 ⎠⎟ 2
⎛ a + b ⎞⎟ 3 ⎛⎜ b − a ⎞⎟
x 3 = ⎜⎜ ⎟ + ·⎜ ⎟ , c3 = c1
⎜⎝ 2 ⎠⎟ 5 ⎝⎜ 2 ⎠⎟
35
Los puntos se calcularán como elementos de un vector x de tres

elementos y los coeficientes como elementos de un vector c de tres
elementos. El procedimiento se llamará pgauss3 y se salvará en un
fichero en disquete llamado “pgauss3.m”.
b) Escribir un procedimiento MAPLE en el que dados tres puntos {x1, x2, x3}
y tres coeficientes {c1, c2, c3} así como dos funciones f y g se calcule el
valor:
4
valor = ∑ c i ·f(xi )·g(xi )
i=1
El procedimiento se llamará pescfun3 y se salvará en un fichero en

disquete llamado “pescfun3.m”.
c) Escribir un programa MAPLE en el que dadas las funciones:

f1(x) = 1 + x2, f2(x) = x + (x3 /3) , f3(x) = 1 + x + x2 + x3 , f4(x) = 1
y los valores a = 0 y b = 3:
1º) Utilice el procedimiento pgauss3 para calcular los tres puntos x y pesos
c correspondientes a los valores de a y b que se acaban de proporcionar.
2º) Calcule las funciones g1(x), g2(x) , g3(x), y g4(x) definidas como sigue:
g1(x) = f1(x),
g2(x) = f2(x) – α2,1·g1(x) ,
g3(x) = f3(x) – α3,1·g1(x) – α3,2·g2(x)
g4(x) = f4(x) – α4,1·g1(x) – α4,2·g2(x) – α4,3·g3(x)
donde los valores αi,j (i = 2, 3, 4; j = 1,.. i-1) se calcularán con ayuda del
procedimiento pescfun ya que se corresponden a los valores :
3
αi,j = ∑ c ·f (x
k =1
k i k )·g j (xk )
siendo los puntos y pesos {xk} y {ck} (k = 1, .., 3) los calculados con el
procedimiento pgauss3.
3º) Dibuje las cuatro funciones g1(x), g2(x) , g3(x) y g4(x) en el intervalo [a, b]
mostrando las cuatro gráficas en un mismo dibujo y con diferentes colores.
36
(Valoración de cada apartado: a) 1 punto, b) 1’5 puntos, c) 2’5 puntos)
Solución:
a)
> restart;
> pgauss3:=proc(a,b,x,c)
x:=vector(3):
c:=vector(3):
x[1]:=((a+b)-sqrt(3./5.)*(b-a))/2.: c[1]:=5.*(b-a)/18.:
x[2]:=(a+b)/2.: c[2]:=8.*(b-a)/18.:
x[3]:=((a+b)+sqrt(3./5.)*(b-a))/2.: c[3]:=c[1]:
end proc:
> save pgauss3, "pgauss3.m":

> fin_del_primer_procedimiento;
fin_del_primer_procedimiento
b)
> pescfun3:=proc(x,c,f,g,valor)
local resul, i:
resul:=0.:
resul:=resul+c[i]*f(x[i])*g(x[i]):
od:
valor:=resul:
end proc:
> save pescfun3, "pesfun3.m":
> fin_del_segundo_procedimiento;
fin_del_segundo_procedimiento
c)
> restart;
> with(linalg):with(plots):
unprotected
> f[1]:=x-> 1+x^2;

f[2]:=x-> x+x^3/3;
f[3]:=x-> 1+x+x^2+x^3;
f[4]:=x->1;
f 1 := x → 1 + x 2
37
1 3
f 2 := x → x + x
3
f 3 := x → 1 + x + x 2 + x 3
f 4 := x → 1
> a:=0;b:=3;m:=4;
a := 0
b := 3
m := 4
> read "pgauss3.m":
read "pesfun3.m":
> pgauss3(a,b,x,c):
> g[1]:=f[1];
g1 := f 1
> pescfun3(x,c,g[1],g[1],norma[1]):
for j from 1 to (i-1) by 1 do
pescfun3(x,c,f[i],g[j],algo[i,j]):
alpha[i,j]:= algo[i,j]/norma[j]:
od:
g[i]:=f[i]:
g[i]:=g[i]-alpha[i,j]*g[j]:
od:
pescfun3(x,c,g[i],g[i],norma[i]):
od:
> vv:=matrix(m,m):
for j from 1 to m by 1 do
pescfun(x,c,f[i],g[j],valor[i,j]):
vv[i,j]:=valor[i,j]:
od:
od:
> dib1:=plot(g[1](x),x=a..b,color=blue):
dib2:=plot(g[2](x),x=a..b,color=red):
dib3:=plot(g[3](x),x=a..b,color=gold):
dib4:=plot(g[4](x),x=a..b,color=green):
> display(dib1,dib2,dib3,dib4);
38
39
Examen de Laboratorio (Convocatoria de Septiembre. Grupos 3º y 4º)

Fecha: 22 – IX – 2004
Primer ejercicio (2.5 puntos)

La curva denominada “bruja de Agnesi” debe su nombre a la matemática italiana
María Agnesi (Milan, 1718 – Milán, 1799). Su construcción es la siguiente:
Sea una circunferencia de radio r tangente al origen de coordenadas y sea una

tangente a dicha circunferencia paralela al eje Ox. Un punto cualquiera, C, de la curva
se obtiene trazando una recta OB que corte a la circunferencia en A. La ordenada de C
es la de A y su abcisa la de B.
A C
Así, si las coordenadas del punto B son (bi, 2r), la recta OB es:
2r
y= x
bi
y la circunferencia:
x2 + ( y − r ) = r 2
2
cuya intersección es el punto O de coordenadas (0,0) y el A de coordenadas

4bi r 2 8r 3
( 2 , ). Por tanto, el punto C de la curva de Agnesi tiene por
bi + 4r 2 bi2 + 4r 2
8r 3
coordenadas ( bi , ).
bi2 + 4r 2
Se pide construir un programa MAPLE que calcule 50 puntos a la derecha del

origen de coordenadas y otros 50 a la izquierda, de la “bruja de Agnesi” para r = 1 y que
represente gráficamente los puntos obtenidos.
Nota: El nombre de “bruja” proviene de una mala traducción del italiano.

Originalmente, la curva de denominó versoria porque la figura de la curva semejaba el
40
de la “cuerda que dirige la vela” pero el traductor confundió esta palabra con versiera
que significa “bruja”.
Solución:
Construir la curva denominada "bruja de Agnesi"
x = b; y = 8*r^3/(b^2+4*r^2)
> restart:
> with(plots):
> n:=50:
> h:=0.1:
> r:=1:
> b:=vector(2*n+2): x:=vector(2*n+1): y:=vector(2*n+1):
> b[1]:=-50*h:
> for i from 1 to 2*n+1 do

x[i]:= b[i];
y[i]:= 8*r^3/(b[i]^2+4*r^2):
b[i+1]:=b[i]+h:
od:
> dd:=[seq([x[k],y[k]],k=1..2*n+1)]:
> plot(dd, scaling=CONSTRAINED);
41

La resolución de un sistema de ecuaciones lineales de la forma Ax = b puede
realizarse utilizando el método de Gauss con pivote parcial que responde al siguiente
algoritmo:
Dada la matriz A, de dimensión (n,n) y el vector b de dimensión n:

Desde i = 1 hasta n-1 con paso 1 hacer:
k=i
PIVOTE = A[i,i]
Desde j = i+1 hasta n con paso 1 hacer:
Si A[j,i] > PIVOTE entonces
k = j; PIVOTE = A[j,i]
Fin condición
Fin del bucle en j
Desde j = i hasta n con paso 1 hacer:
AUX = A[i,j]; A[i,j] = A[k,j];A[k,j] = AUX
Terminar para j
AUX = b[i]; b[i] = b[k]; b[k] = AUX
Desde j = i+1 hasta n con paso 1 hacer:
m = -A[j,i]/A[i,i]
Desde k = i+1 hasta n con paso 1 hacer
A[j,k] = A[j,k] + m*A[i,k]
Terminar para k
b[j] = b[j] + m*b[i]
Terminar para j
Terminar para i
x[n] = b[n]/A[n,n]
Desde i = n-1 hasta 1 con paso -1 hacer
suma = b[i]
Desde j = i+1 hasta n hacer
suma = suma - A[i,j]*x[j]
Terminar para j
x[i] = suma/A[i,i]
Terminar para i
Imprimir resultados
42
Se pide:
a) Implementar un programa MAPLE que responda al algoritmo dado

b) Aplicar el programa precedente a la resolución del sistema:
⎧ − y − z + 3t = −1
⎪ x − y + 3z − 2t = 6
⎪
⎨
⎪3x − 3 y + 4z + t = 12
⎪⎩ x + y + z = 8
Solución:
Método de Gauss con pivote parcial
> restart:
> with(linalg):
unprotected
> n:=4:
> A:=matrix(n,n,[[0,-1,-1,3],[1,-1,3,-2],[3,-
3,4,+1],[1,1,1,0]]);
⎡0 -1 -1 3⎤
⎢ ⎥
⎢1 -1 3 -2⎥
⎢
A := ⎢ ⎥
⎥
⎢3 -3 4 1⎥
⎢ ⎥
⎢1 1 1 0⎥
⎣ ⎦
> b:=vector(n,[-1,6,12,8]); x:=vector(n):
b := [ -1, 6, 12, 8 ]
> for i from 1 to n-1 do
Búsqueda de la fila pivote
k:=i:
pivote:=abs(A[i,i]):
for j from i+1 to n do
if(abs(A[j,i]) > pivote) then
k:=j:
pivote:= abs(A[j,i]):
fi:
od:
Intercambio de la fila i por la fila pivote
43
for j from i to n do
aux:= A[i,j]:
A[i,j]:= A[k,j]:
A[k,j]:= aux:
od:
aux:= b[i]:
b[i]:= b[k]:
b[k]:= aux:
Anulación por debajo del elemento A[i,i]

m:= -A[j,i]/A[i,i]:
for k from i+1 to n do
A[j,k]:= A[j,k] + m*A[i,k]:
od:
A[j,i]:=0:
b[j]:= b[j] + m*b[i]:
od:
od:
Resolución por remonte del sistema triangular superior resultante

> x[n]:= b[n]/A[n,n]:
> for i from n-1 to 1 by -1 do
suma:= b[i]:
suma:= suma - A[i,j]*x[j]:
od:
x[i]:= suma/A[i,i]:
od:
> print(A,b,x);
⎡ 3 -3 4 1 ⎤
⎢ ⎥
⎢ -1 -1 ⎥⎥
⎢ 0
⎢ 2
3 ⎥⎥
⎢ 3
⎢ ⎥
-7 ⎥⎥, ⎡⎢⎢ 12, 4, 2, ⎤⎥⎥, [ 1, 3, 4, 2 ]
⎢ 12
⎢ 0 5
⎢ 0 ⎥ ⎣ 5⎦
⎢ 3 3 ⎥
⎢ ⎥
⎢ 6 ⎥⎥
⎢
⎢⎢ 0 0 0 ⎥
⎣ 5 ⎥⎦
44
Examen de Laboratorio (Convocatoria de Septiembre. Grupos 5º y 6º)

Fecha: 24 – IX – 2004
Primer ejercicio (2’5 Puntos)

Se pide calcular y representar 500 puntos (xi , yi) (i = 1, …, 500) cuyas
coordenadas responden a las expresiones:
xi = ρi·cos(θi) , yi = (ρi)2·cos2(θi)·sen(θi)
donde los 500 valores θi repartidos uniformemente en el intervalo [0, 6·π] y los
500 valores están dados por ρi = θi
Obtén una aproximación de la longitud del tramo de curva dibujado mediante la

expresión:
500
Long ≈ ∑ (x i − x i−1 )2 + (yi − y i−1 )2
i=1
Solución:
> restart:with(linalg):with(plots):
> n:=500;
h:=evalf(6*Pi/(n-1));
n := 500
h := 0.03777466118
theta:=(i-1)*h:
rho:=sqrt(theta):
y[i]:=(x[i]**2)*sin(theta):
od:
> ptos:=[seq([x[i],y[i]],i=1..n)]:
pointplot(ptos,color=blue,connect=true,symbol=BOX,thickness
=3);
45
> long:=0.:
long:=long+sqrt((x[i]-x[i-1])**2+(y[i]-y[i-1])**2):
od:
> long;
99.81314613
Segundo ejercicio (2’5 Puntos)

Denotando por I a la matriz Identidad de dimensiones (n, n) y por vt al
traspuesto del vector v, programa en MAPLE el siguiente algoritmo:
ALGORITMO
Datos: n, v (vector fila de n elementos), y matriz B (de dimensiones (n, n))
nv Å ||v||2
A Å I – (1/nv)·(vt·v)
B Å A-1
v Å {B11, B12, …., B1,n}
Fin bucle en i.
46
Escribir la matriz A resultante.

Utiliza el programa anterior con los datos
⎡ 1 1.25 −1⎤
n = 3, v = {1, 2, 3} , ⎢
B = ⎢ −2 0 1 ⎥⎥
⎢⎣3.30 1 1 ⎥⎦
Solución:
> restart:with(linalg):with(plots):
> n:=3:
v:=matrix(1,n,[1.,2.,3.]):
B:=matrix(n,n,[[1,1.25,-1],[-2.,0.,1.],[3.3,1.,1.]]):
Id:=matrix(n,n,[[1.,0,0],[0.,1.,0.],[0.,0.,1.]]):
nv:=norm(v,2):
A:=evalm(Id-(1/nv)*evalm(transpose(v)&*v)):
B:=inverse(A):
for j from 1 to n by 1 do
v[1,j]:=B[1,j]:
od:
od:
> evalm(A);
⎡-24.96488338 5.406729315 8.110093978 ⎤
⎢ ⎥
⎢ 5.406729315 -0.125856083 -1.688784124⎥
⎢ ⎥
⎢⎢ 8.110093978 -1.688784124 -1.533176188⎥⎥
⎣ ⎦
Tercer ejercicio (5 Puntos)

Una iteración de método de Halley para resolver una ecuación no lineal,
escrita en la forma f(x) = 0, consiste en, partiendo de una aproximación de
partida de la solución de la ecuación (que denotamos por “a”) calcular otra
aproximación “b” de dicha solución mediante la fórmula:
2.f(a).f '(a)
b = a−
2.(f '(a))2 − f(a).f "(a)
Se pide:
47
A) Escribir un procedimiento MAPLE que tomando como datos el punto “a”,

la función f, su primera derivada fp y su segunda derivada fs, calcule el
valor “b” mediante la fórmula de Halley anterior.
B) Escribir un programa MAPLE que, utilizando el procedimiento anterior
realice n iteraciones del método de Halley para resolver una ecuación de
la forma f(x) = 0. En cada una de las iteraciones, salvo en la primera, se
tomará como valor aproximado de partida el calculado en la iteración
anterior. Para la primera iteración se tomará como valor aproximado de
partida un valor dado α.
Aplica el programa a la resolución de la ecuación: e x − 4 − 8 = 0 tomando
2
como valor inicial α = 4 , y realizando n = 100 iteraciones.
Solución:
A)
> halley:=proc(a,f,fp,fs,b)
b:=a - 2*f(a)*fp(a)/(2*fp(a)*fp(a)-f(a)*fs(a)):
end proc:
> save halley, "A:halley.m":
B)
> restart:
> read "A:halley.m":
> n:=100:
alpha:=4.:
f:=x->exp(x*x-4)-8;
fp:=x->D(f)(x);
fs:=x->D(fp)(x);
(x x − 4)
f := x → e −8
fp := x → D( f )( x )
fs := x → D( fp )( x )
> x:=array(0..n):
x[0]:=alpha:
halley(x[i-1],f,fp,fs,x[i]):
od:
> x[n];
2.465652356
> #Lo que sigue no se pedía en examen
with(plots):
ptos:=[seq([i,x[i]],i=0..n)]:
48
pointplot(ptos,color=blue,symbol=BOX);
49

Curso03 04

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Curso03 04

Загружено:

Авторское право:

Доступные форматы

Programación y Métodos Numéricos Examen de Laboratorio

Carlos Conde, Arturo Hidalgo, Alfredo López Curso 2003- 2004

UNIVERSIDAD POLITÉCNICA DE MADRID

DEPARTAMENTO DE MATEMÁTICA APLICADA

Examen de Laboratorio (Grupo 3º - Jueves de 16h a 18h)

2ª. Al finalizar el examen debe entregarse un disquette etiquetado en el que se graben

Primer ejercicio (2.5 puntos)

siendo x0 y x1 dos puntos, en principio cualesquiera de [a,b]. Si dividimos [a,b]

a) Calcule, mediante la fórmula dada, f ' ( xi ) (i = 0, 1, …, N-1), para N=50,

b) Represente en una gráfica conjuntamente f(x) y df, es decir, la función y

Determinar numericamente la derivada de la función f(x) = cos(x/2)*sin(2x).

> a:=evalf(-Pi); b:=evalf(Pi); N:=50; h:=(b-a)/N;

Declaramos los arrays x (puntos dosnde aproximamos la derivada de f) y df

> x:=array(0..N,[]): df:=array(0..N,[]):x[0]:=a:

Calculamos las derivadas aproximadas df[i] en cada punto x[i] (i = 0, 1, ...,

> for i from 0 to N-1 do

Dibujamos los resultados. Creamos una secuencia, ptos, para el dibujo,

> ptos:=[seq([x[i],df[i]], i=0..N)]:

Creamos el dibujo, dib2, de la función f(x)

> dib2:=plot(f,-Pi..Pi, thickness=2,color=black,

Representamos conjuntamente dib1 y dib2

Segundo ejercicio (2.5 puntos)

El grafo de la figura precedente consta de 5 nodos (numerados del 1 al 5) y 6

La forma habitual de representar un grafo es mediante su matriz de incidencia,

ai , j = 1 si el arco j pasa por el nodo i

Así, la matriz de incidencia para el grafo del ejemplo es:

Existen varios algoritmos para determinar una dendrita de un grafo a partir de su

Dados la matriz de incidencia A, el número de nodos, NNOD y el

Se declaran los vectores STACK(NNOD), EXAM(NNOD),

Desde I = 1 hasta NNOD con paso 1 hacer

Mientras I < NNOD hacer

a) Construir un programa MAPLE que responda al algoritmo dado.

> NNOD:=5: NARC:=6:

Tercer ejercicio (5 puntos)

Dada una matriz cuadrada A de dimensión n, los coeficientes ai de su polinomio

pueden determinarse por el método de Leverrier modificado:

Por otra parte, las raíces del polinomio de grado n:

pueden calcularse utilizando el algoritmo siguiente:

Dados n, a(n), maxiter y eps

Desde i = 1 hasta n-1 hacer

Mientras norma > eps e iter < maxiter hacer

Desde i = 0 hasta i = n-1 hacer

Desde i = 1 hasta i = n-1 hacer

Fin de bucle condicional

a) Construir un procedimiento MAPLE llamado Leverrier que, utilizando como

a Vector con los coeficientes del polinomio característico

calcule los coeficientes del polinomio característico de la matriz A.

b) Construir un procedimiento MAPLE llamado DC que, utilizando como variables

n Grado del polinomio

q Vector con las raíces del polinomio

determine las raíces de un polinomio de grado n.

c) Construir un programa MAPLE que, utilizando los procedimientos construidos en

Determinación de valores propios de una matriz cuadrada utilizando

Warning, the name changecoords has been redefined

for i from n-1 to 0 by -1 do

Examen de Laboratorio (Grupo 4º)

donde z(t) es la población de depredadores en el instante t, c(t) la población de

Una forma (aproximada) de conocer la evolución de la población en el

siendo h = T / NP, y f1(z, c) y f2(z, c) las dos componentes de la función

Se pide que calcules según el esquema anterior la evolución de una

Segundo ejercicio (2’5 Puntos)

En ocasiones, evaluar la derivada en cada iteración es “problemático”

En este ejercicio se pide que escribas un programa MAPLE para obtener