ALGORÍTMICA NUMÉRICA Ejercicios computacionales 0.

Introducción a Matlab: Scripts y funciones. Control de flujo: for, while, if.

________________________________________________________________________________________________

• En algunas cuestiones planteadas se da la respuesta (en color azul). El texto en azul son sentencias de MATLAB.
Podéis ejecutarlas en la ventana de comandos con un cortar y pegar.
• Las respuestas a las preguntas en color rojo se deberán incluir en la Hoja de Entrega.
• La entrega será individual en el plazo de una semana.
_________________________________________________________________________________________________

1. Dar el comando >> edit fun1 para crear la siguiente función fun1.
La función recibe como argumentos de entrada un número x y un entero k y devuelve el valor de cos(k*x).
Para x=2, n=3 se ejecuta con el comando >> p = fun1(2,3). Comprobar que el resultado es el correcto.

function p = fun1(x,k)
p= cos(k*x);
return

2. Escribir una función que reciba como argumentos de entrada un número x y un entero n y devuelva el valor
de la n-ésima potencia de x (x^n). El segundo argumento puede ser opcional. Si se omite debe tomarse
como n=2 (valor por defecto), devolviendo el cuadrado de x.

function y=potencia(x,n) %función potencia y=x^n

if nargin == 1, n=2; end %Si se omite un parámetro de entrada, la función toma n=2
%y=potencia(x,n) calcula y=x^n
%z=potencia(x) calcula z=x^2
y=x^n;
return

Dar el comando >> edit ejer2 para crear el siguiente script.

Se ejecuta con el comando >>ejer2

clear;
x=0.5,n=5,y=potencia(x,n),n=1/5,y=potencia(x,n)

3. Modificar la función del apartado anterior, y=potencia(x,n), para que la variable de entrada x pueda ser un
vector.
Modificar el script ejer2 anterior para ejecutar 4 veces la función potencia con x=[-1:0.01:1], para n=1,2,3,4,
haciendo un plot de las 4 salidas en una sola Figura (superponiendo las funciones en el mismo gráfico con
el comando hold on). Obtener una gráfica similar a la siguiente:

1
ALGORÍTMICA NUMÉRICA Ejercicios computacionales 0.2
Potencias x 1, x 2, x 3 y x 4
1

0.8

0.6

0.4

0.2

-0.2

-0.4

-0.6

-0.8

-1
-1 -0.8 -0.6 -0.4 -0.2 0 0.2 0.4 0.6 0.8 1

4. Escribir una función llamada y =cosn(x,n) que reciba dos argumentos x (vector) y n (número) y devuelva el
vector y = cos n ( x) . Crear el script para ejecutar 3 veces la función cosn con x=-pi:0.1:pi; para n=5, 7, 9, y
almacenar el resultado en una tabla. Hacer un plot de las 3 salidas en una sola Figura.

5. Sea la matriz 5x7 de números aleatorios entre 0 y 1 generada por A=rand(5,7).

a) Usar bucles anidados asignando a cada elemento de A el valor 0.2 si el valor original era menor o
igual a 0.4 y 0.7 si era mayor que 0.4:

for k=1:5, for j=1:7,

if A(k,j)<=0.4, A(k,j)=0.2; else A(k,j)=0.7; end
end; end

b) Repetir usando indexado lógico: A(A<=0.4)=0.2; A(A>0.4)=0.7;

6. Calcular las 50 primeras iteraciones, y dibujar la gráfica, de la siguiente sucesión

 x0 = 0

 xn +1 = cos( xn )
a) Utilizando una tabla x=zeros(51,1);
El siguiente script, crea una tabla inicializada a ceros y en cada iteración almacena el valor de la
sucesión. Hace un plot de la tabla. Muestra el valor de la última iteración.

x=zeros(51,1);
for k=1:50,
x(k+1)=cos(x(k));
end
plot(x,'.')
x(end)

¿Es convergente la sucesión? ¿A qué valor converge la sucesión?

b) Utilizando un número x.

2
ALGORÍTMICA NUMÉRICA Ejercicios computacionales 0.2
Repetir el apartado anterior, donde x en lugar de una tabla sea un escalar. En cada iteración hacer un
plot con hold on.

7. Hacer un script que calcule las 50 primeras iteraciones de la sucesión

 x0 = 0

 1 − xn
 xn +1 = 2 e
¿A qué valor s converge la sucesión xn ?. Llamar s al valor al que converge la sucesión s  x(end )

Dibujar una figura con 3 gráficas:

1. Con el comando subplot(131) mostrar el valor de la sucesión xn , respecto de las iteraciones,

2. Con el comando subplot(132) mostrar el valor del error relativo, respecto de las iteraciones,

Erel  s  xn s

3. Con el comando subplot(133) mostrar el número de cifras de precisión, respecto de las iteraciones,

Ncifras  floor ( log10( Erel ))

En los tres casos utilizar los ejes adecuados. La figura resultante debe ser similar a esta:

0.5 10 0 15

0.45
-2
10

0.4
-4
10
0.35
10
-6
10
0.3

0.25 -8
10

0.2
10 -10
5
0.15

10 -12
0.1

10 -14
0.05

0 10 -16 0
0 20 40 60 0 20 40 0 20 40

8. Utilizar la relación
1 1 1
e = 1+ + + + ...
1! 2! 3!
3
ALGORÍTMICA NUMÉRICA Ejercicios computacionales 0.2

para estimar el valor del número e (en Matlab exp(1)), sumando los primeros 30 términos de la serie.
Calculamos la estimación de 5 formas distintas, unas más eficientes que otras, respecto del coste
computacional (la más eficiente es la que menos operaciones utiliza).

a) Utilizando los comandos .*, ./, .^ (poco eficiente, recalcula el factorial para cada valor de n).
n=[0:29]; fact=factorial(n); s=sum(1./fact)
Sabiendo que e=exp(1) ¿Cuál es el error cometido con la estimación?.

b) Mediante un bucle for (poco eficiente ya que recalcula el factorial).

s=1; for k=1:29, s=s+1/factorial(k); end
¿Obtenemos la misma estimación que en el apartado anterior?.

c) Modificando el bucle anterior para sea más eficiente (calcula el factorial iterativamente).
s=1; temp=1; for k=1:29, temp=temp/k; s=s+temp; end
¿Hay alguna diferencia con la solución anterior?.

d) Repetir el bucle anterior pero de forma que el bucle termine (break) si el término a sumar es menor que
10^(-18). ¿Cuántas iteraciones del bucle se hacen? ¿Hay diferencias entre ambas soluciones?
s=1; temp=1; for k=1:29, temp=temp/k; s=s+temp; if temp<1e-18; break; end; end
¿Cuántas iteraciones del bucle se hacen? ¿Por qué motivo se impone que el bucle termine si el término
a sumar es menor que 10^(-18)?

e) Implementar de forma más elegante el problema anterior usando un bucle while, con la condición de
que el término a sumar sea mayor que 10^(-18). Calcular el número de iteraciones.
s=0; temp=1; k=1; while(temp>1e-18), s=s+temp; temp=temp/k; k=k+1; end

f) Modificar el comando for del apartado c) anterior para añadir en cada iteración el cálculo del
Error= e − s y volcar por pantalla con un fprintf la siguiente información:

Iteración: 1 Aproximación del numero e: 2.0000e+00 Error: 7.1828e-01

Iteración: 2 Aproximación del numero e: 2.5000e+00 Error: 2.1828e-01
Iteración: 3 Aproximación del numero e: 2.6667e+00 Error: 5.1615e-02
.
.

¿Cuántas iteraciones son necesarias para alcanzar 10 cifras de precisión? ¿y 15?

g) Modificar el comando while del apartado e) anterior para dibujar en una gráfica el error. En cada
iteración utilizar el comando semilogy para mostrar el error, respecto del número de iteración (con hold
on). ¿Cuántas iteraciones son necesarias para alcanzar 10 cifras de precisión? ¿y 15?

9. La siguiente sucesión converge a s  2 .

a) Implementar un script, con un bucle for, que calcule las 30 primeras iteraciones de

 x0 = 1

 2 + xn
 x + =
1 + xn
n 1


¿Cuánto difiere la última iteración de s?. A partir de los resultados numéricos obtenidos ¿converge la sucesión
a s?.

4
ALGORÍTMICA NUMÉRICA Ejercicios computacionales 0.2
b) Modificar el script anterior. En cada iteración del bucle usar el comando fprintf() para volcar por pantalla los
siguientes datos: Número de iteración (%2d), Estimación de sqrt(2) (%.15f) y El Error relativo (%.2e).

Erel  s  xn s

El resultado debe ser similar al siguiente:

Numero de iteracion 1 Estimacion de sqrt(2) 1.500000000000000 El Error relativo 6.066017e-02

Numero de iteracion 2 Estimacion de sqrt(2) 1.400000000000000 El Error relativo 1.005051e-02
Numero de iteracion 3 Estimacion de sqrt(2) 1.416666666666667 El Error relativo 1.734607e-03
.
.

¿Cuántas iteraciones son necesarias para alcanzar 10 cifras de precisión?

¿Cuál es la precisión de la máquina? ¿Cuántas iteraciones son necesarias para alcanzar dicha precisión?

c) Modificar el script anterior. Definir la tabla x=zeros(31,1). Repetir el bucle for anterior, almacenando el
resultado en la tabla x.
A partir de la tabla x, con operaciones punto a punto, calcular las tablas Erel y Ncifras.

Ncifras  floor ( log10( Erel ))

Dibujar una figura con 2 gráficas: la estimación y el número de cifras de precisión, respecto de las
iteraciones. Utilizar el comando subplot y los ejes adecuados.

¿Cuál es la pendiente (aproximada) de las cifras de precisión, respecto de las iteraciones? ¿Están
dibujados en la gráfica todos los valores de Ncifras? ¿Porqué?.