IP Practica 4 2022

Depto.
de Ingeniería Geológica y Minera ‐ ETSI Minas y Energía Informática y Programación – Curso 2022/23 Práctica 4ª
• Creación de gráficos
• Subprogramas function
Universidad Politécnica de Madrid
• Mínimos cuadrados
Pr. Carlos Conde Lázaro

Pr. Ángel Fidalgo Blanco
Pr. Roberto Gómez Prieto
Pr. Alfredo López Benito
Pra. Mª Pilar Martínez de la Calle
17 de octubre de 2022
1
Depto. de Ingeniería Geológica y Minera ‐ ETSI Minas y Energía Informática y Programación – Curso 2022/23 Práctica 4ª
El entorno de trabajo en MATLAB

Current Folder:
Ficheros
en la Command window:
carpeta de
trabajo
Área de trabajo para la ejecución de
instrucciones,
programas, …
Workspace:
Nombres de las
variables usadas
y valores que van
tomando
Directorio (carpeta) en la que se está trabajando
Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,
Alfredo López Benito y Mª Pilar Martínez de la Calle 2
LAS FUNCIONES EN MATLAB®
Además de las predefinidas en MATLAB , puedes
definir las que tú quieras ∙∙∙∙∙∙ de alguna de las 4
formas siguientes:
1ª) Escribiéndolas en una única sentencia
(funciones handle).
2ª) Escribiéndolas como un subprograma function.
3ª) Funciones “especiales”: polinomios o definidas por
tramos polinómicos, … (Práctica posterior)
4ª) Utilizando variables simbólicas previamente
declaradas como tales. (Práctica posterior)
LAS FUNCIONES EN MATLAB®
Las definas como las definas, debes saber que:
En MATLAB® una función se comporta como un
programa independiente, que puede ser utilizado

desde Command window o desde otros programas,
asignando valor a uno o más argumentos de entrada
(variables independientes) para calcular el valor de uno o
más argumentos de salida (variables dependientes).
Numerosas funciones forman parte de la plataforma
MATLAB® y se usan escribiendo su nombre y tras él,
encerrados entre paréntesis, los valores (o los nombres de
variables) que dan valor a los argumentos de entrada que
se utilizan. El resultado se puede almacenar en otra
variable.
PROGRAMA SUBPROGRAMA
A= input('A'); Arg. entrada
B=sin(A); Módulo
sin
Arg. salida
1º) El argumento de entrada del módulo sin toma el

valor que tenga la variable A (parámetro de entrada)
2º) Se calcula el valor del seno almacenando su resultado
en el argumento de salida.
3º) El valor del argumento de salida se le asigna a la
variable B (parámetro de salida).
5
Alfredo López Benito y Mª Pilar Martínez de la Calle
B=log(A)+A^2; Módulo
C= cos(B) logaritmo
D=max(abs(C),A/4) Arg. salida
1º) El argumento de entrada del módulo logaritmo toma

el valor que tenga la variable A (parámetro de entrada)
2º) Se calcula el valor del logaritmo almacenando su
resultado en el argumento de salida.
3º) Al valor del argumento de salida se le suma A2 y el
resultado se asigna a la variable B (parámetro de salida).
6
C= cos(B) coseno
1º) El argumento de entrada del módulo coseno toma el

valor que tenga la variable B (parámetro de entrada)
2º) Se calcula el valor del coseno almacenando su
resultado en el argumento de salida.
3º) El valor del argumento de salida se asigna a la
variable C (parámetro de salida).
7
Arg. Arg.
A= input('A'); E-1 E-2
C= cos(B) max
SUBPROGRAMA
Arg. entrada
Módulo
abs
Arg. salida

8
ALGUNA OBSERVACIÓN:
1ª) Las variables que dan valor a los argumentos de
entrada no ven modificado su valor tras ejecutarse la

función.
2ª) El usuario no tiene por qué conocer el nombre dado a

los argumentos de entrada ni a los de salida, ni tampoco
el proceso que se realiza en el módulo. “Lo que pase en el
subprograma se queda en el subprograma”, sin
transmitirse nada al programa salvo los valores de los
argumentos de salida. En el subprograma se utilizan
variables locales.
9
Las funciones handle
Se denominan funciones handle a aquellas que
no son escritas en ficheros diferenciados ni están
predefinidas en MATLAB®. Son funciones “sencillas” que

se definen con una sola instrucción en el espacio de
trabajo o en el programa. Se las denomina también
funciones anónimas.
Su estructura es la siguiente:
nombre = @(arg. entrada) expresión
Se utilizan escribiendo el nombre y, entre paréntesis y
separados por comas, los valores que se quiera asignar a
los argumentos de entrada.
10
EJEMPLO:
>> fun1=@(r,h) h*pi*r^2;
r
>> v=fun1(1.56,2) h
v = 15.2908
2∙π∙1.562
>> fun1=@(r,h) h*pi*r^2;

>> radio=3; altura=4;
>> volumen=fun1(radio,altura)
volumen = 113.0973
4∙π∙32
11
EJEMPLO: z
y
ϕ
x α
>> esf2car=@(R,alpha,phi) ...

[R*cos(alpha)*cos(phi),...
R*sin(alpha)*cos(phi),...
R* sin(phi)]
>>C=esf2car(2,-pi/3,-pi/4)
C =
0.7071 -1.2247 -1.4142
12
OBSERVACIONES:
1ª) Las funciones handle sólo se pueden utilizar mientras

su nombre está activo en Workspace. Tras borrar la
memoria (p.ej.: con clear) es necesario volver a definir
la función antes de usarla
2ª) Las variables utilizadas en la definición son

variables locales (su valor no aparece en
Workspace).

13
AHORA ES UN BUEN MOMENTO PARA QUE

PLANTEES TUS DUDAS
Pues practiquemos con ellas !!!!

Escribe un programa en el que:
1º) Se le soliciten al usuario dos valores reales para las
variables A y B, y … Si A fuera superior a (B-3), se
modificará el valor de A para que coincida con el valor

(B-4)
2º) se genere un vector S con N=601 abscisas
uniformemente repartidas en [A,B]
3º) se defina la función
g(x)=e|cos(x· π)|·sen(x·π/2)
4º) se calcule el valor la función g(x) en A y en B.

g(x) en todas
5º) se calculen los valores de la función
las abscisas dadas por los elementos de S.
15
clear all;
A=input('Valor de A= '); % Se soliciten los
B=input('Valor de B= '); % valores de A y B
if (A>B-3) % Si A>(B‐3)
A=B-4; % A  B‐3
end
% Se repartan 601
N=601; S=linspace(A,B,N); % abscisas en [A,B]
g=@(x) exp(abs(cos(x*pi)))*sin(x*pi/2);
% g(x)=e|cos(x∙π)|∙sen(x∙π/2)
VA=g(A), VB=g(B)
% Se evalúe g(x) en A y en B.
for I=1:1:N
G(I)=g(S(I)); % Se evalúe g(x) en S.
end
16
clear all;
A=input('Valor de A= ');
B=input('Valor de B= ');
if (A>B-3)
A=B-4;
end
S=linspace(A,B,601);
g=@(x) exp(abs(cos(x*pi)))*sin(x*pi/2);
g=@(x) exp(abs(cos(x*pi))).*sin(x*pi/2);
VA=g(A), VB=g(B)
for I=1:1:601 El operador .* permite
G(I)=g(S(I)); G=g(S); multiplicar elemento a
end elemento de un vector
17
Escribe un programa en el que:
1º) ∙∙∙∙∙∙∙∙∙∙∙∙
2º) ∙∙∙∙∙∙∙∙∙∙∙∙
3º) ∙∙∙∙∙∙∙∙∙∙∙∙
4º) ∙∙∙∙∙∙∙∙∙∙∙∙
5º) ∙∙∙∙∙∙∙∙∙∙∙∙
6º) Se represente la función g(x) en [A,B].

18
El comando plot( )
para dibujar nubes de puntos
plot(X,Y,Especificaciones)
Vector de abscisas Vector de ordenadas

de los puntos representados
Indican cómo dibujar (color, símbolo para cada punto,
tipo de línea uniendo los puntos, grosor de línea, ,,,). Si
no se escriben se usan las que MATLAB tiene
predefinidas “por defecto”.
El gráfico se realiza en una ventana gráfica que se abre
automáticamente
19
clear all;
if (A>B-3)
A=B-4;
end
VA=g(A), VB=g(B)
G=g(S);
plot(S, G) Al no haber especificaciones,
MATLAB® dibujará “como quiera”

20
Une los puntos, con una línea continua, de color cian, …

21
Especificaciones (las 3 más simples)
Se escriben entre comillas simples ' '
Símbolo Carácter Línea Carácter Color Carácter

O Continua ‐ Amarillo y
+ + Discontinua ‐‐ Azul b
 x Blanco w
^ Punteada :
Cian c
v Raya‐punto ‐. Negro k
s
Sin línea Rojo r
* * ……………. Verde g
p …………….
…………….
Consulta HELP de MATLAB® (o la Guía de Comandos)
22
clear all; close all;
if (A>B-3)
A=B-4;
end
VA=g(A), VB=g(B)
G=g(S);
plot(S,G,'--r')
Une los puntos con de color rojo
una línea discontinua
23

24
Una especificación más (de las muchas que hay):
EL ANCHO DE LÍNEA
'Linewidth',grosor
donde grosor es un número positivo (siendo el valor

que usa MATLAB® por defecto 0.5)

25
if (A>B-3)
A=B-4;
end
VA=g(A), VB=g(B)
G=g(S);
plot(S,G,'--r','Linewidth',3)
Ancho de línea 3 (seis
Une los puntos con de color rojo veces la usada por defecto)
una línea discontinua
26

27
El comando fplot( )
para dibujar funciones
fplot(funcion,[A,B],Especificaciones)
Nombre de la fución
Intervalo de dibujo
Indican cómo dibujar (color, símbolo para cada punto,

tipo de línea uniendo los puntos, grosor de línea …). Si
no se escriben se usan las que MATLAB tiene
predefinidas “por defecto”.
El gráfico se realiza en una ventana gráfica que se abre
automáticamente
28
clear all;close all;
if (A>B-3)
A=B-4;
end
g=@(x)exp(abs(cos(x*pi))).*sin(x*pi/2);
fplot(g,[A,B],'-r','Linewidth',3)

29

30
Los subprogramas function
Son ficheros escritos con la estructura siguiente:
function [ARG_SAL.]=nombre(ARG_ENT.)
% Comentarios (opcionales)
Instrucciones (se recomienda terminarlas
en “;” para evitar “ecos” en pantalla)
end (opcional)
con: [ARG_SAL.] lista de argumentos de salida

separados por comas “,” y entre corchetes NOMBRE LOCAL DE
LOS RESULTADOS
y: (ARG_ENT.) lista de argumentos de entrada

separados por comas “,” y entre paréntesis NOMBRE LOCAL DE
LOS DATOS

31
• Los argumentos de entrada y de salida son nombres
de variables simples, vectores, matrices … u otras
funciones handle o simbólicas.

• Las instrucciones pueden ser cualesquiera, y en ellas
pueden emplearse otras variables locales. También
pueden utilizarse otros subprogramas function.
• Todas las variables usadas en una función son, por
defecto, locales, es decir no aparecen en la ventana
Workspace y no se “mezclan” con las de los
programas que las utilicen aunque tengan el mismo
nombre.
• No utilices clear o instrucciones similares.
32
Una vez escrito un script function se debe salvar, en

el directorio de trabajo, en un fichero con el mismo
nombre que la función y con extensión .m. (o .mlx si

usas LIVE EDITOR)
Para utilizar un script function debes:
1º) Asegurarte de que el fichero que lo contiene está en el

directorio de trabajo (aparece en la ventana Current
folder).
y:

33
2º) Escribir
[PARÁMETROS SALIDA]=nombre(PARÁMETROS ENT.)
con: [PARÁMETROS SALIDA] lista de variables,
encerradas entre corchetes y separadas por comas “,””, a

las que la función transferirá los valores de los
argumentos de salida. Debe haber tantos parámetros
como argumentos NOMBRE DE LAS VARIABLES DEL PROGRAMA QUE
TOMARÄN EL VALOR DE LOS RESULTADOS
y: (PARÁMETROS ENT.) lista de variables y/o
constantes y/o expresiones, encerradas entre paréntesis y
separadas por comas “,””, de las que la función tomará los
valores de los argumentos de entrada. Debe haber tantos
parámetros como argumentos
CONSTANTES Y/O VARIABLES Y/O EXPRESIONES DEL PROGRAMA QUE
DARÁN VALOR A LOS DATOS
34
SUBPROGRAMA
LOCALES
LOCALES
function[as1,as2,···,asm]=nombre(ae1,ae2,···,aen)
Valores VS1 VS2 … VSm VE1 VE2 … VEn
[PS1,PS2,···,PSm]=nombre(PE1,PE2,···,PEn)
GLOBALES GLOBALES
PROGRAMA (o en Command Window)

35
OjO MUY IMPORTANTE (Y SE OLVIDA CADA DÍA!!!)

¡¡¡LAS VARIABLES QUE ACTÚEN COMO

PARÁMETROS DE ENTRADA DEBEN TENER VALOR
ASIGNADO PREVIAMENTE (O HABER SIDO DECLARADAS COMO
SIMBÓLICAS)!!!!.
¡¡¡LOS ARGUMENTOS DE ENTRADA NO DEBEN

LEERSE EN EL SCRIPT function!!!!.

36
AHORA ES UN BUEN MOMENTO PARA QUE

PLANTEES TUS DUDAS

RECUERDA QUE dadas n funciones linealmente
independientes {φ1(x),φ2(x),···,φn(x)}, y
siendo {c1,c2,∙∙∙,cn} los n coeficientes de la función:
q(x)=g(x)+c1φ1(x)+c2φ2(x)+ ···+cnφn(x)
que aproxima por mínimos cuadrados la nube de m
puntos (S1,Y1), (S2,Y2), ∙∙∙, (Sm,Ym), se calculan resolviendo el
sistema de ecuaciones:
m
[M]·{C} = {b}
donde: M I,J   I SK ·J  SK  (I,J 1,2,
···,n)
K 1
m
y: bI   YK g SK  ·I SK  (I1,2,
···,n)
K 1
38
Escribe un subprograma function, llamado
AMCG, en el que sean argumentos de entrada:
• Un vector fila S (abscisas de los puntos)
• Un vector fila Y (con el mismo número de

elementos que S) (ordenadas de los puntos)
• Una función handle vectorial columna,
dependiente de un único argumento, llamada
fi. (funciones {φ1(x),φ2(x),···,φn(x)} )
• Una función función handle g (g(x))
con los que se calculará un vector {C} cuyas
componentes sean los coeficientes de la función
q(x)=g(x)+c1φ1(x)+c2φ2(x)+···+cnφn(x)
que aproxima por M.C. la nube de puntos (S,Y).
39
: IDEA DEL ALGORITMO

y 1º) Evaluamos las funciones {φ1(x),φ2(x),
···,φn(x)} en {S1, S2,∙∙∙. Sm}
2º) Evaluamos el vactor Z con Zk  Yk –g(Sk)

(k=1,2,…,n)
3º) Calculamos: n
MI,J   I Sk ·J  Sk  (I,J1,2,
···,m)
k 1
n
y:
k 1

bI  Yk g Sk  ·I Skk   (I1,2,
···,m)
4º) {C}  [M]-1·{b}

40

y 1º) Evaluamos las funciones {φ1(x),φ2(x),
···,φn(x)} en {S1, S2,∙∙∙, Sm}
φ1(S1) φ1(S2···
) φ1(SJ)··· φ1(Sm)
φ2(S1) φ2(S2···
) φ2(SJ)··· φ2(Sm)
··· ··· ··· ··· ··· ···
[P]  φI(S1) φI(S2···
) φI(SJ)··· φI(Sm)
··· ··· ··· ··· ··· ···
φn(S1) φn(S2···
) φn(SJ)··· φn(Sm)

41
[C] Módulo AMCG(S,Y,fi,g)
m  Nº de elementos de S;
n  Nº de elementos de fi;
I=1,1,n
J=1,1,m
PI,J  fiI(SJ)
+
42

y 2º) Evaluamos Zk  Yk-g(Sk)
-
I=1,1,m
ZIYI-g(SI)

43
IDEA DEL ALGORITMO
m
3º) MI,J   I Sk ·J  Sk  (I,J 1,2,
···,n)
k 1
- Producto escalar
I=1,1,n
J=1,1,n
MI,J{PI,1:m}•{PJ,1:m}
+
44
IDEA DELn ALGORITMO
k 1

3º) bI  Yk g Sk  ·I Sk   (I1,2,
···,n)
- Producto escalar
I=1,1,n
bI{Z}•{PI,1:m}
+
45
IDEA DEL ALGORITMO
4º) {C}  [M]-1·{b}
-
{C}[M]-1·{b}
FIN Módulo AMCG

46
I=1,1,n
bI{Z}•{PI,1:m}

47
SUBPROGRAMA MATLAB: function AMGC
function [C] = AMCG(S,Y,fi,g)
P=fi(S)
[n,m]=size(P);
Z=(Y-g(S));

48
P=fi(S)
[n,m]=size(P);
Z =(Y-g(S)).’;
for I=1:1:n
for J=1:1:n
M(I,J)=dot(P(I,1:m),P(J,1:m);
end
end Producto escalar de dos vectores

49
P=fi(S);
[m,n]=size(P);
Z =(Y-g(S)).';
for I=1:1:n
for J=1:1:n
M(I,J)=dot(P(I,1:m),P(J,1:m);
end
b(I,1)=dot(Z,P(I,1:m);
end
50
···········
for I=1:1:n
for J=1:1:n
M(I,J)=dot(P(I,1:m),P(J,1:m));
end
b(I,1)=dot(Z,P(I,1:m));
end
C=inv(M)*b;
end

51
P=fi(S);
Al evaluarse en un VECTOR
[n,m]=size(P); deben definirse con operadores
Z =(Y-g(S)).'; ∙elemento a elemento” (los
operadores .*, ./ y .^)
for I=1:1:n
for J=1:1:n
M(I,J)=dot(P(I,1:m),P(J,1:m));
end
b(I,1)=dot(Z,P(I,1:m));
end
C=inv(M)*b;
end
52
SALVEMOS EL SCRIPT …
Save Ctrl+S
Save As …
Save All…
Save Copy As … Directorio
Nombre AMCG (El mismo

que la función)
Extensión (.m)
AMCG

Save Ctrl+S
Save As …
Save All…
Save Copy As … Directorio
Nombre AMCG (El mismo

que la función)
Extensión (.m)
AMCG


Escribe un PROGRAMA en el que:
1º) se genere una nube de 101 puntos cuyas
abscisas se repartan uniformemente en [‐4, 4] y
cuyas abscisas se generen aleatoriamente en

[0,17]:
2º) se calculen los coeficientes de la función

q(x) = 1+c1·x+x2+c2·x3+ c3·cos(π·x)
que aproxima por mínimos cuadrados a la nube
de puntos anterior.

56
q(x) = 1+c1·x+x2+c2·x3+ c3·cos(π·x)

2 N=101; AX=-4; BX=4; AY=0; BY=17;
3 S=linspace(AX,BX,N); Salvado en
4 Y=AY+(BY-AY)*rand(1,N); el fichero
5 fi=@(x) [x; x.^3; cos(pi*x)]; PR1_AMCG,m
6 g =@(x) 1+x.^2;
7 [C] = AMCG(S,Y,fi,g);
8 C
q(x) = 1+c1·x+x2+c2·x3+ c3·cos(π·x)

57
En unos minutos ejecutaremos el programa

que llama al subprograma
… pero antes ¿hay alguna duda?

1º) se genere una nube de 101 puntos cuyas abscisas se repartan
uniformemente en [‐4, 4] y cuyas abscisas se generen
aleatoriamente en [0,17]:
q(x) = 1+c1·x+x2+c2·x3+ c3·cos(π·x)
que aproxima por mínimos cuadrados a la nube de puntos
anterior.
3º) Se represente gráficamente la nube de puntos

59
1 clear all; close all;
2 N=101; AX=-4; BX=4; AY=0; BY=6;
3 S=linspace(AX,BX,N);
4 Y=AY+(BY-AY)*rand(1,N);
5 fi=@(x) [x; x.^3; cos(pi*x)];
6 g =@(x) 1+x.^2;
8 C Al no haber especificaciones, MATLAB
9 plot(S,Y) dibujará “como quiera”
Une los puntos,
con una línea continua,
de color cian,
…

60
2 N=101; AX=-4; BX=4; AY=0; BY=6;
5 fi=@(x) [x; x.^3; cos(pi*x)];
6 g =@(x) 1+x.^2;
8 C
9 plot(S,Y,'or')
18
16
14
12
10
0
-4 -3 -2 -1 0 1 2 3 4

61
1º) se genere una nube de 101 puntos cuyas abscisas se repartan
uniformemente en [‐4, 4] y cuyas abscisas se generen
aleatoriamente en [0,6]:
q(x) = 1+c1·x+x2+c2·x3+ c3·cos(π·x)
que aproxima por mínimos cuadrados a la nube de puntos
anterior.
3º) Se represente gráficamente la nube de puntos
4º) Se represente gráficamente la función q(x)

62
2 N=101; AX=-4; BX=4; AY=0; BY=6;
5 fi=@(x) [x; x.^3; cos(pi*x)];
6 g =@(x) 1+x.^2;
7 [C] = AMCG(S,Y,fi,g); Permite realizar más
8 C gráficas en la misma
9 plot(S,Y,'or') ventana de dibujo, no
10 hold on cerrándose hasta que se
11 for I=1:1:N escriba hold off
12 Q(I)=g(S(I))+dot(C,fi(S(I)));
13 end
14 plot(S,Q,'-b')
63
q(x)=1+0.1228·x+x2+( ‐0.0522) ·x3+(‐0.9392)·cos(π·x)

64
En prácticas posteriores presentaremos más opciones
y otras formas de “dibujar”.
… pero antes ¿hay alguna duda?
Pues a continuación tienes unos cuantos

ejercicios propuestos …
65
RECUERDA QUE, EN EL AULA, VIMOS QUE EL POLINOMIO
INTERPOLADOR (EN EL SENTIDO DE LAGRANGE), DE UNA FUNCIÓN
f(x) SOBRE UN SOPORTE {s1, s2, s3, …, sn} TENÍA SUS
COEFICIENTES CANÓNICOS:
p(x)=a1+a2·x+a3·x2+···+an·x(n-1)
DADOS COMO SOLUCIÓN DEL SISTEMA:
 1) (n  1)
 1 s1  s(J  s  a

1 1
  1  f(s1)
(J  1) (n  1)    
 1 s2  s2  s2  a2  f(s2)
   
            
1 s  s  
·
     
(J 1)
 sJ(n 1)
 aJ   f(sJ )
 J J 
    
          
 
 1 s  s(J  1)  s(n  1)   an   f(sn )
 n n n 
66
EJERCICIO PROPUESTO 1º
A) Escribe un subprograma function, llamado P_LAG,
que teniendo como argumentos de entrada:

• un vector S,
• una función handle f
calcule como argumento de salida el vector a que
contiene los coeficientes canónicos del polinomio que
interpola en el sentido de Lagrange a la función f sobre el
soporte S.

67
EJERCICIO PROPUESTO 1º)(Solución apartado A))
function [a]=P_LAG(S,f)
[m,n]=size(S); % Dimensiones del vector S
if (m==1) % Si S es vector fila ...

X=S.’; % ... X es columna de n elem.
else % Si S es vector columna ...
n=m; X=S; % ... X es columna de n elem.
end
XX=X; % Inicializamos XX (que será S^J)
M(1:n,1)=1; % 1ª coluna de la matriz
M(1:n,2)=XX; % 2ª coluna de la matriz (sop.)
b(1,1)=f(S(1)); % Primeros 2 elementos del
b(2,1)=f(S(2)); % vector de 2º término
(Continúa en página siguiente)

68
EJERCICIO PROPUESTO 1º)(Solución apartado A))
(Viene de la página anterior)
if (n>2) % Si hay más de 2 abscisas ...
for J=3:1:n % Calculamos columnas 3 a n

XX=XX.*X; %... Actualizando XX=S^(J-1)
M(1:n,J)=XX; %... almacenándolo en la
% coluna J ...
b(J,1)=f(S(J)); % ... y calculamos b(J)
end
end
a=inv(M)*b; % Resolvemos el sistema lineal
end % Finalizamos el subprograma

69
EJERCICIO PROPUESTO 1º) (Apartado B)
B) Escribe un programa, y sálvalo en un fichero llamado
PR_LAG, en el que, utilizando el subprograma realizado
en el apartado anterior, se calculen los coeficientes del

polinomio que interpolaen el sentido de Lagrange a la
función f(x)= cos(x·π)∙sen( π∙e‐|x|) sobre el soporte
de abscisas S={-2,-1,0,2,3,5,7}
Representa en una misma gráfica y con colores diferentes

la función f(x) y el polinomio interpolador

70
EJERCICIO PROPUESTO 1º)(Solución apartado B))
S=[-2,-1,0,2,3,5,7]; % Soporte
n=length(S); % Nº de abscisas
% Función interpolada
f=@(x) cos(x*pi).*sin(pi*exp(-abs(x)));
[a]=P_LAG(S,f); % Coefs. Pol. Interpol.
% Abscisas de dibujo
XD=linspace(S(1),S(end),451).';
YD=f(XD); % Ordenadas de f(x) en sop.
% Dibujo de f(x)
plot(XD,YD,'-b','Linewidth',3);
hold on % Mantenemos “ventana” abierta
71
EJERCICIO PROPUESTO 1º)(Solución apartado B) (cont.))
nd=length(XD); % Nº abscisas de dibujo
% Cálculo de valores del polinomio
PD(1:nd,1)=a(1);
xd=XD;
for J=2:n
k=a(J);
PD(1:nd,1)=PD(1:nd,1)+k*xd(1:nd,1);
xd=xd.*XD;
end
plot(XD,PD,'-r','Linewidth',2); %Dibujo
plot(S, f(S),'ok','Linewidth’,3);
legend('f(x)','p(x)','Soporte')
grid on; grid minor;
72

73
Probablemente recordarás que …
Mi J-ésimo
polinomio de base
asociado al soporte
{s1, s2,…,sJ,…, sn}
tiene valor 1 en sJ y
nulo en las demás
abscisas
¿Escribimos una function, llamada PBL, en la

que, dado un soporte S, se calculen los
coeficientes de los polinomios de base de
Lagrange a él asociados ?
Profesores Carlos Conde, Ángel Fidalgo, Roberto Gómez Prieto
74
Alfredo López y Mª Pilar Martínez de la Calle
EJERCICIO PROPUESTO 1º)(Apartado A))
A) Escribe un subprograma function, llamado PBL,
que teniendo como argumento de entrada el vector de
abscisas S, calcule una matriz C en la que su J‐ésima

columna contenga los coeficientes del J‐ésimo polinomio
de base de Lagrange asociado al soporte S (es decir aquel
que en sJ tiene valor 1 y se anula en las otras abscisas del
0
vector S). 1 s1  s1  s1  c
(J  1) (n  1)
0
   1,J   
(J  1) (n  1)  
 1 s2  s2  s2  c2,J  
     
          0
1 s (n  1)   c
·    
 sJ (J  1)
 sJ  J,J   1 Fila J
 J 
  0
          
 
1 s  s(J  1)
 s  cn,J 
(n  1)    
 n n n   
0
75
EJERCICIO PROPUESTO 1º)(Solución partado A))
function [C]=PBL(S)
n=length(S); M=zeros(n);
for I=1:1:n
M(I,1)=1; X(I,1)=S(I);
end
for J=2:1:n
M(1:n,J)=M(1:n,J-1).*X;
end
C=inv(M);
end

76
EJERCICIO PROPUESTO 2º)(Apartado B))
B) Escribe un programa que calcule los coeficientes de los
polinomios de base de Lagrange asociados al soporte
S={-2,-1,0,2,3,5}, y represente cada uno de

dichos polinomios en diferentes subventanas gráficas
AYUDA: Consulta el comando subplot( ) en el Help

de MATLAB® o en la Guía de Comandos

77
S=[-2,-1,0,2,3,5]; n=length(S);
[C]=PBL(S); % Matriz de coeficientes
A=min(S); B=max(S);
XD=[A:0.1:B]; % Abscisas de dibujo
m=length(XD);
% La fila I de la matriz MX contiene
% las potencias (I-1) de las abscisas
MX(1,1:m)=1;; MX(2,1:m)=XD;
for I=3:1:n
MX(I,1:m)=MX(I-1,1:m).*XD;
end
YD=C.'*MX; % Valores de los polinomios
78
ND=ceil(n/2);
for I=1:1:n
subplot(ND,2,I) % Subventana nº I
plot(XD,YD(I,1:m),'-r','Linewidth',2);
hold on
YS=zeros(1,n); YS(I)=1;
plot(S,YS,'ok','Linewidth',2)
plot([A,B],[0,0],'--b','Linewidth',2);
plot([A,B],[1,1],'--b','Linewidth',2);
xlim([A,B]);ylim([-2,2]);
grid on; grid minor;
title(['Polinomio de base ',num2str(I)])
end

79

80
EJERCICIO PROPUESTO 3º)
Escribe un subprograma function en MATLAB®
que, con los argumentos de entrada Z10 (un
número real dado en base 10) y N (un número

entero superior a 3) calcule como argumento de
salida un vector, llamado b, con (N+1) elementos,
y un entero k, tales que:
• El primer elemento de b indique el signo.
• Los N elementos siguientes de b recojan los
primeros N dígitos significativos de la expresión
binaria de Z10.
• y k sea el mayor entero para el que: 2k|Z10|
81
EJERCICIO PROPUESTO 3 – Proceso de resolución
1º) Calculamos el entero k tal que 2k sea la
mayor potencia de 2 igual o menor que |Z10|
2º) SI Z10 <0: asignamos a b1 el valor 1,

SI NO: asignamos a b1 el valor 0.
3º) Asignamos a resto el valor |Z10| y :
Para J=0, 1, 2, …,N-1
SI (2(k-J)≤ resto): bJ+21;
SI NO: bJ+20;
resto  resto – bJ+2·2(k-J)
Fin bucle en J
82
EJERCICIO PROPUESTO 3 – Proceso de resolución
1º) Calculamos el entero k tal que 2k sea la
mayor potencia de 2 igual o menor que |Z10|
2º) SI Z10 <0: asignamos a b1 el valor 1,

SI NO: asignamos a b1 el valor 0.
CONDICIONALES
3º) Asignamos a resto el valor |Z10| y :
Estructuras
Para J=0, 1, 2, …,N-1
SI (2(k-J)≤ resto): bJ+21;
BUCLE
SI NO: bJ+20;
resto  resto – bJ+2·2(k-J)
Fin bucle en J
83
EJERCICIO PROPUESTO 3 – PSEUDOCÓDIGO
Función [b,k]  COD2(Z10,N) Puesta a 0 de los N+1
elementos del vector b
Z|Z10|; k0; P1; b(1:N+1)0
SI (Z>=1) entonces:
Mientras (P ≤ Z) hacer:
Bucle
P  2*P; k  k+1; condicional
Fin bucle condicional
DE BIFURCACIÓN
Estructura
k  k-1; P  P/2;
SI NO, SI (Z > 0):
Mientras (P > Z) hacer:
Bucle
P  P/2; k  k-1; condicional
Fin bucle condicional
FIN condición
(Continúa en la página siguiente)
84
SI (Z10<0):
DE BIFURCACIÓN
b1  1;
Estructura
SI NO: 1ª componente del vector b:

b1  0; el indicador del signo (un 0 si es
Fin condición positivo o un 1 si es negativo)
(Continúa en la página siguiente)

85
resto  Z;
Para J, desde 0, con paso 1, hasta N-1:

SI (P <= resto):
DE BIFURCACIÓN
b2+J1; restoresto–P; PP/2;

Estructura
SI NO:
b2+J0; PP/2;
Fin condición
Fin bucle Dígitos b2 a bN+1.
Escribir los elementos del vector b y el valor de k.
FIN de la función COD2

86
EJERCICIO PROPUESTO 3 – ORGANIGRAMA
Función [b,k]  COD2(Z10,N)
Z  |Z10|; k  0;
P1; b(1:1:N)0
87
-
NO NO
Z>1? Z>0?
SI SI
P≤Z? P>Z?
P2·P; kk+1; PP/2; kk-1;
PP/2; kk-1;
+
Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto, 88
-
Z10<0? NO
SI
b11; b10;
resto  Z

89
-
J=0:1:(N-1)
NO
P<resto?
SI
b2+J  1; b2+J  0;
restoresto-P;
P  P/2 P  P/2
b,k FIN función

90
EJERCICIO PROPUESTO 3 – PROGRAMA MATLAB
function [b,k]=COD2(Z10,N)
2 Z = abs(Z10); Z|Z10|; k0; P1;
3 k=0;
4 P=1; Z>1?
5 if (Z>1)
P≤Z?
6 while (P<=Z)
7 P=2*P; k=k+1; P2·P; kk+1;
8 end
9 P=P/2; k=k-1; PP/2; kk-1;

9 P=P/2; k=k-1; PP/2; kk-1;
10 elseif (Z>0) Z>1?

NO
Z>0?
11 while (P>Z)
12 P=P/2; k = k-1; P>Z?
13 end PP/2; kk-1;
14 end
15 if (Z10<0)
NO
Z10<0?
16 b(1)=1;
SI
17 else
b11; b10;
18 b(1)=0;
19 end

19 end
20 resto = Z; resto  Z
21 for J=0:1:(N-1)
J=0:1:(N-1)
22 if (P < resto)
23 b(J+2)=1; NO
P<resto?
24 resto=resto-P;
SI
25 P=P/2; b2+J  1; b2+J  0;
26 else restoresto-P;
27 b(J+2)=0; P  P/2 P  P/2
28 P=P/2;
29 end
30 end
31 end FIN de la función

PULSA SOBRE EL ICONO Save

Y EN EL MENÚ DESPLEGABLE
SELECCIONA Save As …

SE TE ABRIRÁ UNA NUEVA VENTANA
ASEGÚRATE DE ESTAR EN EL
DIRECTORIO DE TRABAJO
ASÍGNALE EL MISMO NOMBRE QUE
A LA FUNCIÓN (COD2)
MANTÉN LA EXTENSIÓN .m
PULSA SOBRE Guardar

ASEGÚRATE DE QUE EL FICHERO

APARECE EN EL DIRECTORIO DE
TRABAJO QUE FIGURA EN LA
VENTANA Current Folder
[B, EXPO] = COD2(3*pi,15)

Tras el prompt de la ventana Command window escribe:
• el nombre de los PARÁMETROS DE SALIDA, (entre corchetes)
• el OPERADOR DE ASIGNACIÓN (=),
• el NOMBRE DE LA FUNCIÓN,
• y los PARÁMETROS DE ENTRADA (entre paréntesis y con valor previo)

>> [B,EXPO] = COD2(3*pi,15)
B =
0 1 0 0 1 0 1 1 0 1 1 0 0 1 0 1
EXPO =
3
(3·π)10=(9.4247779607693…)10=
=(+1.00101101100101…·23)2

Realiza un PROGRAMA en el que:
1º) se le solicite al usuario un número real Z10 no nulo

y dos enteros positivos N y t, siendo N>5 y t>3
2º) se asegure que Z10 no es nulo, y en caso de serlo se
le insista al usuario para que lo modifique,
3º) se asegure que N y t son enteros superiores a 5 y 3,
y si no lo fueran se le inste al usuario a modificaarlos
4º) usando la función COD2, se obtenga el código
binario de Z10 con mantisas de (N+1) bit y
exponentes con (t+1) bit
98
1º) se le solicite al usuario un número real Z10 no nulo

y dos enteros positivos N y t, siendo N>5 y t>3
clear all;
Z10=input('Teclee un valor real NO NULO (Z10): ');
N=input('Nº de digitos de la mantisa (N>5)? ');
t=input('Nº de digitos del exponente (t>3)? ');

99
2º) se asegure que Z10 no es nulo, y en caso de serlo se

le insista al usuario para que lo modifique,
clear all;
Z10=input('Teclee un valor real NO NULO (Z10): ');
N=input('Nº de digitos de la mantisa (N>5)? ');
t=input('Nº de digitos del exponente (t>3)? ');
while (Z10==0)
display('Z10 NO PUEDE SER NULO');
Z10=input('Vuelva a teclear el valor de Z10 ');
end
100

while (Z10==0)
display('Z10 NO PUEDE SER NULO');
Z10=input('Vuelva a teclear el valor de Z10 ');
end
while (N~=floor(N) | N<6)
display('N DEBE SER ENTERO MAYOR QUE 5');
N=input('Vuelva a teclear el valor de N ');
end
101

while (N~=floor(N) | N<6)
display('N DEBE SER ENTERO MAYOR QUE 5');
N=input('Vuelva a teclear el valor de N ');
end
while (t~=floor(t) | t<4)
display(‘t DEBE SER ENTERO MAYOR QUE 3’);
t=input('Vuelva a teclear el valor de t ');
end
102

binario de Z10 con mantisas de (N+1) bit y
exponentes con t bit
Conocido el vector b y el entero k mediante el

uso del subprograma COD2, el código buscado
consistirá en rellenar los N bit del vector m en el
que se almacene la mantisa mediante:
m1  b1; mJ  bJ+1 (J=2,…,N)
103

binario de Z10 con mantisas de (N+1) bit y …
while (t~=floor(t) | t<4)
display(‘t DEBE SER ENTERO MAYOR QUE 3');
N=input('Vuelva a teclear el valor de t ');
end
[b,k] = COD2(Z10,N);
m(1)=b(1); m(2:N)=b(3:1:N+1);

104

binario de Z10 ∙∙∙ con exponentes con t bit
Para obtener el vector e con t bit del exponente,

previamente debemos expresar en binario el
número k. Y eso … ya sabes …
…ya sabes …

105
1º) Buscamos el entero I tal que 2I sea la mayor
potencia de 2 inferior o igual a |k|.
2º) Si I es mayor que (t-2) el exponente no puede

codificarse.
Si no 2‐1) Inicializo E como el vector nulo de t elementos
2‐2) Si k<0, asigno a E1 el valor 1.
2‐3) Asigno a r el valor de |k|.
2‐4) Para J= 2,3,…,t
Si 2(t-J)≤r entonces: EJ1; rr-2(t-J).
si no: EJ0
106
∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙
[b,k] = COD2(Z10,N);
m(1)=b(1); m(2:N)=b(3:1:N+1);
e = zeros(1,t);
if (k < 0)
e(1) =1;
end
r = abs(k); P = 2^(t‐1);
∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙

107
∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙∙
r = abs(k); P = 2^(t‐1);
for J=2:1:t
P = P/2;
if (P<= r);
e(J)=1; r = r‐P;
else
e(J)=0;
end
end
display(['MANTISA =',mat2str(m)]);
display(['EXPONENTE =',mat2str(e)]);
108
Save as PR3_EJ2.m
>> PR3_EJ2
Teclee un valor real NO NULO (Z10): 3/pi^2
Nº de digitos de la mantisa (N>5)? 18
Nº de digitos del exponente (t>3)? 8
MANTISA=[0 0 0 1 1 0 1 1 1 0 1 0 0 0 0 1 0 0]
EXPONENTE =[1 0 0 0 0 0 1 0]
-2
(3/π2)10 = (+1.00110111010000100…∙2‐10)2
109
LA CONVERSIÓN A BINARIO DE MATLAB®,
El comando dec2bin de MATLAB

decimal binary
tw o
Proporciona un string conteniendo la la expresión
binaria de un número ENTERO positivo dado en base 10
Z2=dec2bin(Z10)
EJEMPLO
>> N2=dec2bin(487692)
N2 ='1110111000100001100'
LA CONVERSIÓN A DECIMAL DE MATLAB®,
El comando bin2dec de MATLAB

binary decimal
tw o
Proporciona el entero Z10 positivo en base 10
correspondiente a una cadena binaria Z2
Z10=bin2dec(Z2)
EJEMPLO
>> N10=bin2dec('1110111000100001100')
N10 = 487692
EJERCICIO PROPUESTO Nº 5
a) Averigua cómo funciona el comando:
Z2=dec2bin(Z10)
cuando Z10 es un vector o una matriz
b) Averigua cómo funciona el comando:

Z2=dec2bin(Z10, m)
cuando Z10 es un vector o una matriz, y m es un
entero positivo

Nos vemos la semana que viene (practicaremos más con bucles y

estructuras de bifurcación y, además, aprenderemos a DIBUJAR
con MATLAB). Hasta entonces …
NO DUDES EN CONSULTARLE AL PROFESOR DE TU GRUPO LAS
DUDAS QUE TENGAS

IP Practica 4 2022

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

IP Practica 4 2022

Cargado por

Copyright:

Formatos disponibles

Depto.

Pr. Carlos Conde Lázaro

El entorno de trabajo en MATLAB

programa independiente, que puede ser utilizado

1º) El argumento de entrada del módulo sin toma el

1º) El argumento de entrada del módulo logaritmo toma

1º) El argumento de entrada del módulo coseno toma el

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

entrada no ven modificado su valor tras ejecutarse la

2ª) El usuario no tiene por qué conocer el nombre dado a

predefinidas en MATLAB®. Son funciones “sencillas” que

>> fun1=@(r,h) h*pi*r^2;

>> esf2car=@(R,alpha,phi) ...

1ª) Las funciones handle sólo se pueden utilizar mientras

2ª) Las variables utilizadas en la definición son

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

AHORA ES UN BUEN MOMENTO PARA QUE

Pues practiquemos con ellas !!!!

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

modificará el valor de A para que coincida con el valor

4º) se calcule el valor la función g(x) en A y en B.

6º) Se represente la función g(x) en [A,B].

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

Vector de abscisas Vector de ordenadas

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

Símbolo Carácter Línea Carácter Color Carácter

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

donde grosor es un número positivo (siendo el valor

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

Indican cómo dibujar (color, símbolo para cada punto,

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

con: [ARG_SAL.] lista de argumentos de salida

y: (ARG_ENT.) lista de argumentos de entrada

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

funciones handle o simbólicas.

Una vez escrito un script function se debe salvar, en

nombre que la función y con extensión .m. (o .mlx si

1º) Asegurarte de que el fichero que lo contiene está en el

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

encerradas entre corchetes y separadas por comas “,””, a

Valores VS1 VS2 … VSm VE1 VE2 … VEn

PROGRAMA (o en Command Window)

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

OjO MUY IMPORTANTE (Y SE OLVIDA CADA DÍA!!!)

¡¡¡LAS VARIABLES QUE ACTÚEN COMO

¡¡¡LOS ARGUMENTOS DE ENTRADA NO DEBEN

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

AHORA ES UN BUEN MOMENTO PARA QUE

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

• Un vector fila Y (con el mismo número de

: IDEA DEL ALGORITMO

···,φn(x)} en {S1, S2,∙∙∙. Sm}

2º) Evaluamos el vactor Z con Zk  Yk –g(Sk)

4º) {C}  [M]-1·{b}

: IDEA DEL ALGORITMO

···,φn(x)} en {S1, S2,∙∙∙, Sm}

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

: IDEA DEL ALGORITMO

Carlos Conde Lázaro , Ángel Fidalgo Blanco, Roberto Gómez Prieto,

FIN Módulo AMCG

>> fun1=@(r,h) hpir^2;