Tema 1

Contenido
1. R=chol(A) CON PIVOTAJE.....................................................................................................4
2. B=lugauss(A) (factorización cholesky SIN PIVOTAJE)...........................................................4
3. B=A\b...................................................................................................................................5
4. Forward y backsubs.............................................................................................................6
5. Factorización PA=LU............................................................................................................7
6. A=Q*R..................................................................................................................................8
7. Autovalores y radio espectral..............................................................................................9
8. Matriz de Jacobi...................................................................................................................9
9. Matriz de Gauss-Seidel......................................................................................................10
10. Matriz de relajación.......................................................................................................11
11. Discos de Gerschgorin....................................................................................................12
12. Método QR PARA VALORES PROPIOS...........................................................................12
13. Método eigqrshift y eigqr..............................................................................................14
14. Metodo de givenshessqr...............................................................................................15
15. Método de potencias.....................................................................................................16
16. Método de potencias inverso........................................................................................19
17. Construcción de la pseudoinversa..................................................................................20
18. Comprobación de que A es igual a la suma de matrices de rango 1...............................22
19. Cálculo de la pseudoinversa mediante factorizaion QR de una matriz n*m...................23
MÉTODO 1: Función pinv.......................................................................................................24
MÉTODO 2: Producto inversa A’*A por A.............................................................................24
Método 3: Factorización QR..................................................................................................24
20. Compresión de imágenes...............................................................................................25
21. Factor de compresión.....................................................................................................27
22. El error relativo en la norma 2:.......................................................................................27
23. Ecuaciones no lineales....................................................................................................27
1.Método Newton(newton):.................................................................................................27
2. Método de newton con gráficas (fzero):...........................................................................28
3.Función newtonsys.............................................................................................................30
*Evolución de las iteraciones:............................................................................................32
24. Resolver sistema de ecuaciones....................................................................................33
25. Sistemas de ecuaciones (tres ecuaciones no lineales con tres incógnitas)...................33
26. Cálculo de raíces de polinomios. La matriz compañera................................................36
Polinomios con raíces reales.................................................................................................36
 Type roots..........................................................................................................................36
Poly....................................................................................................................................36
Fzero..................................................................................................................................36
Polinomios con raíces imaginarias........................................................................................37
Compan..............................................................................................................................37
Transpose...........................................................................................................................37
Errores de redondeo entre matriz compañera y la matriz del texto de Trefethen-Bau...38
27. Interpolación polinómica...............................................................................................38
Interpolación de Lagrange baricéntrica:...............................................................................38
Comprobación del polinomio interpolatorio de Lagrange obtenido..................................39
Gráfica del polinomio de interpolación:.............................................................................40
Ajuste polinómico (con coeficientes del polinomio interpolante)......................................40
Ajuste polinómico (sin coeficientes del polinomio interpolante).......................................41
Interpolación de Lagrange baricéntrica................................................................................41
Gráfica del polinomio con fórmula baricéntrica.................................................................45
Evaluación del polinomio de interpolación en los puntos de Chebyshev............................45
Gráfica de interpolación en puntos de Chebyshev.............................................................46
Interpolación de Hermite:.....................................................................................................46
Gráfica del polinomio de Hermite......................................................................................47
28. Auste polinómico por mínimos cuadrados....................................................................48
Resolviendo las ecuaciones normales................................................................................48
Backlash.............................................................................................................................49
Factorización A = QR...........................................................................................................50
Pseudoinversa....................................................................................................................51
Polyfit.................................................................................................................................53
29. Problemas de regresión con dos variables independientes.........................................54
30. Aproximar la derivada segunda en un punto c.............................................................58
31. La regla de Simpson compuesta....................................................................................59
FUNCIONES................................................................................................................................65
EJEMPLOS

1. R=chol(A) CON PIVOTAJE

>> A=[1 2 -2; 2 7 5; -2 5 35]

A=
2. B=lugauss(A) (factorización cholesky SIN
1 2 -2 PIVOTAJE)
2 7 5 >> A=[4 -2 0; -2 3 -2; 0 -2 6]

-2 5 35 A=

>> %Aplico Cholesky para hallar la 4 -2 0

factorización de la matriz A=R'*R con pivotaje -2 3 -2
>> R=chol(A) 0 -2 6
R= >> %Aplico cholesky sin pivotaje para factorizar la
1.0000 2.0000 -2.0000 matriz

0 1.7321 5.1962 >> B=lugauss(A)

0 0 2.0000 B=

>> %Comprobación 4.0000 -2.0000 0

>> R' -0.5000 2.0000 -2.0000

ans = 0 -1.0000 4.0000

1.0000 0 0 >> %Como hemos obtenido la B=U+L separo las

dos matrices
2.0000 1.7321 0
>> U=triu(B)
-2.0000 5.1962 2.0000
U=
>> B=R'*R
4 -2 0
B=
0 2 -2
1 2 -2
0 0 4
2 7 5
>> L=tril(B,-1)
-2 5 35
L=
>> %La matriz es simétrica y positiva
0 0 0

-0.5000 0 0

0 -1.0000 0

>> L=L+eye(3)

L=

1.0000 0 0

-0.5000 1.0000 0

0 -1.0000 1.0000

>> %Como sabemos que U=sqrt(D)+L' sacamos la

matriz DS=sqrt(D)
>> for i=1:3

v(i)=sqrt(U(i,i));

end

>> %Ahora meto el vector v formado por la raiz de

la diagonal de U en la diagonal de DS

>> DS=diag(v)

DS =

2.0000 0 0
3. B=A\b
0 1.4142 0
>>%Introducimos la matriz A
0 0 2.0000
>> A = [4,-2,0; -,3,-2; 0,-2,6]
>> %Finalmente obtenemos la R=DS*L'
A=
>> R=DS*L'
4 -2 0
R=
-2 3 -2
2.0000 -1.0000 0
0 -2 6
0 1.4142 -1.4142
>>%Introducimos la matriz b
0 0 2.0000
>> b = [-4,8,-2]'
>> %Comprobación con chol(A)
b=
>> J=chol(A)
-4
J=
8
2.0000 -1.0000 0
-2
0 1.4142 -1.4142
>>%Calculamos la solución del sistema dividiendo
0 0 2.0000 A entre b o dicho de otra forma calculamos la
inversa de A y la multiplicamos por la matriz b

>>B=A\b

B=

1.0000

4.0000

1.0000
 >> %Como sabemos que U=sqrt(D)+L' sacamos la
matriz DS=sqrt(D

>> for i = 1:3

v(i) = sqrt(U(i,i));

end

>> %Ahora meto el vector v formado por la raiz de

la diagonal de U en la diagonal de DS

>> DS=diag(v)

DS =

2.0000 0 0

0 1.4142 0
4. Forward y backsubs
>> A =[1,2,3; 2,5,8; 3,9,16] 0 0 2.0000
A= >> %Finalmente obtenemos la R=DS*L'
123 >> R=DS*L'
258 R=
3 9 16 2.0000 -1.0000 0
>>%Calculamos R usando la factorización LU 0 1.4142 -1.4142
sin pivotaje:
0 0 2.0000
>> B=lugauss(A)
>>
B=
>> y=forward(R',b)
4.0000 -2.0000 0
y=
-0.5000 2.0000 -2.0000
-2.0000
0 -1.0000 4.0000
4.2426
>> %Como hemos obtenido la B=U+L separo las
2.0000
dos matrices
>>
>> L=tril(B,-1)+eye(3)
>> 6/sqrt(2)
L=
ans =
1.0000 0 0
4.2426
-0.5000 1.0000 0
>>
0 -1.0000 1.0000
>> x=backsubs(R,y)
>> U=triu(B)
x=
U=
1.0000
4 -2 0
4.0000
0 2 -2
1.0000
004
 U=

8.0000 7.0000 9.0000

0 -0.7500 -1.2500

0 0 -0.6667

P=

0 0 1

1 0 0

0 1 0

>> %Comprobamos que las matrices son correctas

haciendo que PA=LU

>>L*U

ans =

8 7 9

2 1 1

4 3 3
5. Factorización PA=LU
>>% Introducimos la matriz A >> P*A

>>A=[2,1,1; 4,3,3; 8,7,9] ans =

A= 8 7 9

2 1 1 2 1 1

4 3 3 4 3 3

8 7 9 >> %Una vez comprobado pasamos a resolver el

sistema:
>> %Introducimos la matriz b
>> C=P*b
>> b=[2,4,10]'
C=
b=
10
2
2
4
4
10
>> y=L\C
>> %Metemos la función [L,U,P]=lu(A) que nos va
a dar las Matrices de la factorización PA=LU y=

>> [L,U,P]=lu(A) 10.0000

L= -0.5000

1.0000 0 0 -0.6667

0.2500 1.0000 0 >> x=U\y

0.5000 0.6667 1.0000 x=

 1 Q=

-1 -0.3333 0.6667 -0.6667

1 0.6667 -0.3333 -0.6667

-0.6667 -0.6667 -0.3333

R=

-3 -2 -1

0 -1 0

0 0 -1

>>%Comprobamos que A=Q*R

>> Q*R

ans =

1.0000 -0.0000 1.0000

-2.0000 -1.0000 0.0000

2.0000 2.0000 1.0000

>>%Comprobamos también que la matriz Q

es ortogonal(Q’*Q=I)

>> Q'*Q

ans =

1.0000 0.0000 -0.0000

6. A=Q*R
>>%Metemos la matriz A 0.0000 1.0000 0.0000

>> A=[1,0,1; -2,-1,0; 2,2,1] -0.0000 0.0000 1.0000

A= >>%Resolvemos el sistema

1 0 1 >> y = Q'*b

-2 -1 0 y=

2 2 1 -12.0000

>>%Metemos la matriz b -2.0000

>> b=[4,-6,10]' -2.0000

b= >> x = R\y

4 x=

-6 2.0000

10 2.0000

>>%Sacamos las matrices Q y R 2.0000

>> [Q,R]=qr(A)
 >> %La suma de los autovalores es la traza de la
matriz

>> trace(A)

ans =

20

>> %Los autovalores se pueden obtener a partir

de la función eig()

>> %Y van a encontrarse según el teorema de los

discos de Gerschgorin

>> %Entre el centro y el radio del disco

>> eig(A)

ans =

2.2679

3.0000

4.0000

5.0000

5.7321

>> %El radio espectral es el autovalor con modulo

mas alto

>> autovalor=max(abs(eig(A)))

autovalor =

5.7321

>> radioespectral=max(abs(eig(A)))

radioespectral =

5.7321
7. Autovalores y radio espectral
>> %Cálculo de autovalores de una matriz para ver
si es definida positiva

>> A = [4,-1,0,0,0; -1,4,-1,0,0; 0,-1,4,-1,0; 0,0,-1,4,-

8. Matriz de Jacobi
1; 0,0,0,-1,4]
>>%Construcción matriz de Jacobi
A=
>> %Comenzamos metiendo la diagonal de A en el
4 -1 0 0 0 vector v

-1 4 -1 0 0 >> v=diag(A)

0 -1 4 -1 0 v=

0 0 -1 4 -1 4

0 0 0 -1 4 4
 4 -0.0000

4 0.2500

4 0.433

>> %construimos una matriz con la diagonal >> radioespectral=max(abs(eig(BJ)))

formada por el vector v
radioespectral =
>> SJ=diag(v)
0.4330
SJ =

4 0 0 0 0

0 4 0 0 0

0 0 4 0 0

0 0 0 4 0

0 0 0 0 4

>> %separamos la diagonal de A del resto

>> TJ=SJ-A

TJ =

0 1 0 0 0

1 0 1 0 0

0 1 0 1 0

0 0 1 0 1

0 0 0 1 0

>> %Finalmente obtenemos la matriz de Jacobi

>> BJ=inv(SJ)*TJ

BJ =

0 0.2500 0 0 0

0.2500 0 0.2500 0 0

0 0.2500 0 0.2500 0

0 0 0.2500 0 0.2500

0 0 0 0.2500 0

>> %De la que también podeos sacar los

autovalores y raido espectral

>> eig(BJ)

ans = 9. Matriz de Gauss-Seidel

>> %Construcción de matriz de Gauss-Seidel
-0.4330

-0.2500
>> %Comenzamos formando una matriz autovalores =
compuesta por los elementos de la matriz A
0
que se encuentren por encima de la diagonal
0.1875
>> SG=tril(A)
0.0625
SG =
-0.0000
4 0 0 0 0
0.0000
-1 4 0 0 0
>> %como tiene un autovalor cero no
0 -1 4 0 0
sabemos si es definida positivia
0 0 -1 4 0
>> radioespectral=max(abs(eig(BG)))
0 0 0 -1 4
radioespectral =
>> %A continuación formaremos una nueva
0.1875
matriz de la resta de la ultima matriz menos la
A

>> TG = SG-A

TG =

0 1 0 0 0

0 0 1 0 0

0 0 0 1 0

0 0 0 0 1

0 0 0 0 0

>> %Finalmente sacamos la matriz de Gauss-

Seidel con la inversa de SG multiplicada por
TG

>> BG=inv(SG)*TG

BG =

0 0.2500 0 0 0

0 0.0625 0.2500 0 0

0 0.0156 0.0625 0.2500 0

0 0.0039 0.0156 0.0625 0.2500

0 0.0010 0.0039 0.0156 0.0625

>> %También podemos obtener los

autovalores y radio espectral de esta ultima
como hemos visto anteriormente

>> autovalores=eig(BG)
 0 0 0 0 -0.1972

>> %Finalmente obtendremos nuestra matriz

de relajación haciendo:

>> BR=inv(SR)*TR
10. Matriz de relajación
>> %Construcción de matriz de relajación BR BR =

>> %Sacamos la diagonal en el vector v -0.0519 0.2630 0 0 0

>> v -0.0136 0.0173 0.2630 0 0

v= -0.0036 0.0045 0.0173 0.2630 0

4 -0.0009 0.0012 0.0045 0.0173 0.2630

4 -0.0002 0.0003 0.0012 0.0045 0.0173

4 >> %De la que obtendremos los autovalores y

radio espectral:
4
>> autovalores=eig(BR)
4
autovalores =
>> %calculamos omegaop=2/(1+sqrt(1-
radioespectralgaussseidel)) 0.0519 + 0.0000i

>> omegaop=2/(1+sqrt(1-radioespectral)) 0.0519 + 0.0000i

omegaop = -0.0173 + 0.0489i

1.0519 -0.0173 - 0.0489i

>> %Construimos la matriz -0.0519 + 0.0000i

SR=(1/omegaop)*diag(v)+tril(A,-1) >> %Podemos ver que tienen parte real e
>> SR=(1/omegaop)*diag(v)+tril(A,-1) imaginaria

SR = >> %el radio espectral será el mayor de las

partes reales
3.8028 0 0 0 0
>> RADIOESPECTRAL=max(abs(eig(BR)))
-1.0000 3.8028 0 0 0
RADIOESPECTRAL =
0 -1.0000 3.8028 0 0
0.0519
0 0 -1.0000 3.8028 0
11. Discos de Gerschgorin
0 0 0 -1.0000 3.8028
>> %Introducimos la primera matriz
>> %Ahora la matriz TR=SR-A
>> A=[4,-1,0,0; -1,4,-1,0; 0,-1,4,-1; 0,0,-1,4]
>> TR=SR-A
A=
TR =
4 -1 0 0
-0.1972 1.0000 0 0 0
-1 4 -1 0
0 -0.1972 1.0000 0 0
0 -1 4 -1
0 0 -0.1972 1.0000 0
0 0 -1 4
0 0 0 -0.1972 1.0000
 >> %Aplicamos método de discos de 100
Gerschgorin
>> %Vemos si es convergente en el número
>> %que nos genera dos diagramas con los de iteraciones metido
discos
>> D=qrbasic(A,tol,kmax)
>> %indicando en que intervalos se
Warning: The method does not converge in
encuentran los valores
the maximum number of iterations\n
>> %propios por filas o columnas
> In qrbasic (line 16)
>> gershcircles(A)
D=
>> %con la función eig(A) sacamos el valor
5.6180
exacto de los valores propios
4.6180
>> valorespropios=eig(A)
3.3820
valorespropios=
2.3820
2.3820
>> %Aumentando el número de iteraciones
3.3820
nos aseguramos de que converja, esto es
4.6180 debido a que hemos tomado una tolerancia
demasiado baja por lo que el numero de
5.6180
iteraciones tienen que ser elevado.
12. Método QR PARA VALORES PROPIOS >> kmax = 200
EJEMPLO 1: VALORES PROPIOS REALES
kmax =
>> %Introducimos la matriz
200
>> A=[4,-1,0,0; -1,4,-1,0; 0,-1,4,-1; 0,0,-1,4]
>> D=qrbasic(A,tol,kmax)
A=
The method converges in 179 iterations
4 -1 0 0
D=
-1 4 -1 0
5.6180
0 -1 4 -1
4.6180
0 0 -1 4
3.3820
>> %Como vemos es tridiagonal simétrica
2.3820
>> %Para ver si converge hacemos:
>> %Así obtenemos en que número mínimo
>> %Metemos una tolerancia en este caso de de iteraciones en el que el
10^-16
>> % método converge y los valores propios
>> tol=1.e-15
EJEMPLO 2: VALORES PROPIOS NO REALES
tol =
>> %Introducimos la matriz
1.0000e-15
>> A=[190,66,-84,30; 66,303,42,-36; 336,-
>> %Y un número de iteraciones aleatorio 168,147,-112; 30,-36,28,291]

>> kmax = 100 A=

kmax = 190 66 -84 30

 66 303 42 -36 -343.7325 121.8263 167.3469 33.6546

336 -168 147 -112 0 -82.6415 297.8094 -20.1784

30 -36 28 291 0 0 -28.7316 321.3643

>> valorespropiosdeA=eig(A) >> %La matriz de Hessenberg cumple que

P*H*P'=A y que P'*P=I
valorespropiosdeA =
>> %El método de QR solo se puede usar con
1.0e+02 *
matrices de Hessenberg
1.4700 + 1.9600i
>> %donde H tiene los mismos valores
1.4700 - 1.9600i propios que A, si no no nos valdría

2.9400 + 0.0000i >> %Una vez formada la matriz de

Hessenberg usamos la función qrbasic
3.4300 + 0.0000i
>> %igual que antes metiendo la matriz de la
>> %Podemos ver que son numero complejos que quiero sacar los valores propios
>> %La traza de A va a ser la suma de los >> %la tolerancia y el número de iteraciones
autovalores
>> [T,D]=qrbasicoT(A,1.e-15,100)
>> trazaA=trace(A)
Warning: The method does not converge in
trazaA = the maximum number of iterations\n
931 > In qrbasicoT (line 16)
>> T=
sumavalorespropios=sum(valorespropiosA)
343.0000 0.0000 -0.0000 -0.0000
Unrecognized function or variable
'valorespropiosA'. 0.0000 294.0000 0.0000 0.0000

Did you mean: 0.0000 -0.0000 235.6525 362.2593

>>sumavalorespropios=sum(valorespropiosde -0.0000 0.0000 -127.7407 58.3475

A)
D=
sumavalorespropios =
343.0000
931.0000
294.0000
>> %Transformamos entonces la matriz a la
235.6525
forma de Hessenberg
58.3475
>> [P,H]=hess(A)
>> %Aunque no es convergente debido al
P=
número de iteraciones insuficiente tenemos
1.0000 0 0 0 la matriz T

0 -0.1920 0.8797 -0.4350 >> %que es una matriz a la que llegamos

0 -0.9775 -0.2109 0.0051
0 -0.0873 0.4262 0.900
H=
190.0000 66.8194 88.5588 -2.1245
después de esas iteraciones
>> %Esa matriz tiene un bloque diagonal 2 x 2
cuyos valores propios son los que nos falta
por calcular de A
>> B = T(3:4,3:4)
B= 2.9400 + 0.0000i

235.6525 362.2593 3.4300 + 0.0000i

-127.7407 58.3475 >> eig(H)

>> eig(B) ans =

ans = 1.0e+02 *

1.0e+02 * 1.4700 + 1.9600i

1.4700 + 1.9600i 1.4700 - 1.9600i

1.4700 - 1.9600i 2.9400 + 0.0000i

>> D 3.4300 + 0.0000i

D= 13. Método eigqrshift y eigqr

343.0000 >> format short

294.0000 >> A=[-7,2,-1,7,-8; 6,-5,-9,1,10; -4,3,-6,10,-10;

1,4,9,-9,6; -7,5,-7,-1,7]
235.6525
A=
58.3475
-7 2 -1 7 -8
>> %Ahora tenemos los siguientes
autovalores: D(!),D(2) y los imaginarios de B 6 -5 -9 1 10

>> D(1) -4 3 -6 10 -10

ans = 1 4 9 -9 6

343.0000 -7 5 -7 -1 7

>> D(2) >> H=hess(A)

ans = H=

294.0000 -7.0000 -7.8222 -0.0855 -5.4477 5.2085

>> eig(B) -10.0995 -9.6569 1.0505 0.7712 3.0882

ans = 0 11.4507 -1.3692 13.9597 -5.7396

1.0e+02 * 0 0 16.6944 -2.5483 -4.2948

1.4700 + 1.9600i 0 0 0 4.5531 0.5744

1.4700 - 1.9600i >> E1 = eigqrshift(A,1.e-10,100)

>> %Podemos comprobar la solución E1 =

haciendo: -21.7464
>> eig(A) 13.0354
ans = -9.8560
1.0e+02 * -3.7993
1.4700 + 1.9600i 2.3663
1.4700 - 1.9600i >> E2 = eigqr(A,1.e-10,100)
E2 = 0 0.8551 -0.1879 0.4832

-21.7464 0 0 0.9320 0.3624

13.0354 R=

-9.8560 4.1231 3.3955 2.6679 1.9403

-3.7993 0 2.3389 2.1126 3.5964

2.3663 0 0 4.2918 1.6836

>> sum(E1) 0 0 0 -1.5705

ans = >> [Qm,Rm]=qr(H)

-20.0000 Qm =

>> sum(E2) -0.2425 0.5030 0.3006 -0.7732

ans = -0.9701 -0.1257 -0.0752 0.1933

-20.0000 0 0.8551 -0.1879 0.4832

>> %Eliminando el punto y coma en el algoritmo 0 0 0.9320 0.3624

en la sentencia iter = iter + 1;
Rm =
>> %puede verse que el algoritmo eigqr (que no
-4.1231 -3.3955 -2.6679 -1.9403
usa desplazamientos) necesita más iteraciones
0 2.3389 2.1126 3.5964
>> %para el mismo valor de la tolerancia.
0 0 4.2918 1.6836
14. Metodo de givenshessqr
>> %La función givenshessqr calcula la 0 0 0 -1.5705
factorización QR de una matriz de Hessenberg
>> Q*R
>> %haciendo uso del método de las
ans =
rotaciones de Givens.
1.0000 2.0000 3.0000 4.0000
>> %Introducimos la matriz
4.0000 3.0000 2.0000 1.0000
>> H = [1,2,3,4; 4,3,2,1; 0,2,1,2; 0,0,4,1]
0 2.0000 1.0000 2.0000
H=
0 0 4.0000 1.0000
1 2 3 4
>> Qm*Rm
4 3 2 1
ans =
0 2 1 2
1.0000 2.0000 3.0000 4.0000
0 0 4 1
4.0000 3.0000 2.0000 1.0000
>> %Hay que trabajar en la carpeta de FORD
ya que es una función de este libro 0 2.0000 1.0000 2.0000
>> [Q, R] = givenshessqr(H) 0 0 4.0000 1.0000
Q= >> %Tenemos QR = Qm * Rm = A, y las
matrices RQ y Rm*Qm mantienen la forma de
0.2425 0.5030 0.3006 -0.7732
>> %Hessenberg (pero no son iguales)
0.9701 -0.1257 -0.0752 0.1933
>> R*Q 15. Método de potencias
>> %Introducimos la matriz
ans =
>> A = [1,2,4; 3,1,2; 4,2,1]
4.2941 3.9282 2.2915 -0.5391
A=
2.2691 1.5123 2.7791 2.7764
1 2 4
0 3.6699 0.7627 2.6841
3 1 2
0 0 -1.4637 -0.5692
4 2 1
>> Rm*Qm
>> %A continuación sacamos los autovalores
ans =
de la matriz A
4.2941 -3.9282 -2.2915 0.5391
>> %y los ponemos en forma de matrices
-2.2691 1.5123 2.7791 2.7764
>> [V,D] = eig(A)
0 3.6699 0.7627 2.6841
V=
0 0 -1.4637 -0.5692
-0.6021 -0.7442 0.3125
>> %Finalmente, observamos que la función
-0.5243 0.2481 -0.8971
qrbasic (de Quarteroni), que no usa
-0.6021 0.6202 0.3125
>> %la forma de Hessenberg, necesita
muchas más iteraciones D=

>> D1=qrbasic(A,1.e-10,200) 6.7417 0 0

'qrbasic' is not found in the current folder or 0 -3.0000 0

on the MATLAB path, but exists in:
0 0 -0.7417
D:\2cuatri\METODOS MATEMATICOS\
funciones\QUARTERONI(metodos iterativos) >> %comprobamos que V'*V es igual a la
identidad en la diagonal
Change the MATLAB current folder or add its
folder to the MATLAB path. >> V'*V

>> %Cambiamos de carpeta a QUARTERONI ans =

>> D1=qrbasic(A,1.e-10,200) 1.0000 -0.0554 0.0941

The method converges in 113 iterations -0.0554 1.0000 -0.2613

D1 = 0.0941 -0.2613 1.0000

-21.7464 >> %Localizamos los valores propios a traves

de los discos de Gerschgorin
13.0354
>> %(sACAMOS LOS GRAFICOS)
-9.8560
>> gershcircles(A)
-3.7993
>> %Aplicamos en primer lugar el método de
2.3663 potencias con la función eigpower,

>> sum(D1) >> % que nos dará el valor propio dominante

y el vector propio correspondiente
ans =
>> %Antes daremos valores a la tolerancia y
-20.0000
numero de iteraciones
>> tol=1.e-10 6.7417

tol = >> A*v1 - D(1,1)*v1

1.0000e-10 ans =

>> nmax=100 1.0e-14 *

nmax = -0.1776

100 0.0888

>> x0=[1,0,0]' 0

x0 = >> %Si el valor de la tolerancia es más

pequeño la precisión será mayor (a costa
1
>> % de llevar a cabo más iteraciones)
0
>> %Aplicamos ahora la técnica de deflación
0
(con el método de Wielandt)
>> [lambda,x,iter]=eigpower(A,tol,nmax,x0)
>> x(1)
lambda =
ans =
6.7417
0.6021
x=
>> lambda
0.6021
lambda =
0.5243
6.7417
0.6021
>> r1=A(1,:)
iter =
r1 =
27
1 2 4
>> A*x - lambda*x
>> vt=(1/(lambda*x(1)))*r1
ans =
vt =
1.0e-08 *
0.2464 0.4927 0.9854
0.2695
>> %Comprobamos que el producto de vt por
-0.0759 el vector propio x es igual a 1

-0.2034 >> vt*x

>> v1=V(:,1) ans =

v1 = 1.0000

-0.6021 >> %Calculamos la matriz B, que debe tener

los valores propios de A, salvo
-0.5243
>> % el que ya hemos calculado que es
-0.6021 reemplazado por el valor propio 0;
>> D(1,1) >> % así, el segundo será ahora el dominante
ans = >> B=A - lambda*x*vt
B= 0

0 0 0 >> [lambda2,x2,iter]=eigpower(Bh,1.e-
15,nmax,x0)
2.1292 -0.7417 -1.4833
lambda2 =
3.0000 -0.0000 -3.0000
-3.0000
>> Bh = B(2:3,2:3)
x2 =
Bh =
0.5490
-0.7417 -1.4833
0.8358
-0.0000 -3.0000
iter =
>> eig(Bh)
40
ans =
>> %A partir de este vector propio de Bh
-0.7417
podemos calcular u2, el
-3.0000
>> %correspondiente vector propio de A
>> %
>> w2=[0,x2(1),x2(2)]'
>> %Aplicamos el método de potencias a la
w2 =
matriz Bh
0
>> [lambda2,x2,iter]=eigpower(Bh,1.e-
15,nmax,x0) 0.5490

Error using * 0.8358

Incorrect dimensions for matrix >> u3=x

multiplication. Check that the number of
u3 =
columns in the
0.6021
first matrix matches the number of rows in
the second matrix. To perform elementwise 0.5243
multiplication, use '.*'. 0.6021
Error in eigpower (line 20) >> u2=(lambda2-lambda)*w2 +
lambda*(vt*w2)*u3
pro = A*x0;
u2 =
Related documentation
4.4413
>> x0
-1.4804
x0 =
-3.7011
1
>> %Normalizamos
0
>> V
0
V=
>> x0=[1;0]
-0.6021 -0.7442 0.3125
x0 =
-0.5243 0.2481 -0.8971
1
 -0.6021 0.6202 0.3125 x0 =

>> V(:,2) 1 0 0

ans = >> x0=[1,0,0]'

-0.7442 x0 =

0.2481 1

0.6202 0

>> norm(u2,2) 0

ans = >> %Los discos de Gerschgorin nos ayudan a

ver que (siendo los valores propios reales)
5.9678
>> %el valor propio más pequeño es el más
>> v2 = V(:,2)
próximo a -5, por lo que podemos elegir mu =
v2 = -5

-0.7442 >> mu = -5

0.2481 mu =

0.6202 -5

>> norm(v2,2) >> [lambda,x,iter]=invshift(A,mu,1.e-

15,nmax,x0)
ans =
lambda =
1
-3.0000
>> k=norm(u2,2)
x=
k=
0.7442
5.9678
-0.2481
>> k*v2
-0.6202
ans =
iter =
-4.4413
42
1.4804
>> %Por otro lado, el valor propio más grande
3.7011 es el más próximo a 7; tomamos mu = 7
>> k*v2+u2 >> mu = 7
ans = mu =
1.0e-10 * 7
0.9351 >> [lambda,x,iter]=invshift(A,mu,1.e-
15,nmax,x0)
0.7421
lambda =
0.8252
6.7417
16. Método de potencias inverso
>> x0=[1,0,0] x=
 -0.6021 6.7417

-0.5243 x=

-0.6021 0.6021

iter =

11

>> %El método de potencias inverso es muy

eficiente (para calcular con precisión el 0.5243

>> % valor propio y su correspondiente vector 0.6021

propio) cuando partimos de una
iter =
aproximación
4
>> %inicial del correspondiente valor propio.
>> format long
>> %Por ejemplo, si tenemos una
aproximación inicial por ejemplo con qrbasic >> [V,D]=eig(A)
(con tolerancia
V=
>> % grande y por lo tanto con pocas
iteraciones) D=

>> nmax=50

nmax =

50

>> D=qrbasic(A,1.e-4,nmax) >> %Observamos que la iteración inversa

converge en solamente cuatro iteraciones y
The method converges in 15 iterations
nos da
D=
>> %valores muy precisos (comparados con la
6.7417 función eig de MATLAB) para el valor propio

-3.0000 >> %y el vector propio.

-0.7417 17. Construcción de la pseudoinversa

>> mu=D(1) METODO 1 ( n ≠ r )

mu = %Inversa de Moore-Penrose

6.7417 >> A=[1,0; 0,1; 1,1]

>> x0=[1,0,0]' A=

x0 = 1 0

1 0 1

0 1 1

0 >> [U,S,V] = svd(A)

>> [lambda,x,iter]=invshift(A,mu,1.e- U=
15,nmax,x0) -0.4082 0.7071 -0.5774
lambda =
 -0.4082 -0.7071 -0.5774 >> pinv(A)

-0.8165 -0.0000 0.5774 ans =

S= 0.6667 -0.3333 0.3333

1.7321 0 -0.3333 0.6667 0.3333

0 1.0000

0 0 MÉTODO 2 ( n = r )

V= >> A=[1,0; 0,1; 1,1]

-0.7071 0.7071 A=

-0.7071 -0.7071 1 0

>> %donde U y V son ortogonales: U*U'=I y 0 1

V*V'=I
>> %la matriz sigma S es una matriz diagonal
(m*n), donde los valores
>> %singulares son los elementos no nulos de
la diagonal de S
>> %que van a ser r elementos, r=rango de A
1 1
>> %Cuando las columnas de A son
linealmente independientes (es decir cuando
r = n),
>> % como ocurre en este ejemplo, tenemos
una expresión explícita para la pseudoinversa,

%la función svd nos da los valores singulares >> % que requiere calcular la inversa de A’*A:
en orden decreciente
>> rank(A)
>> %Se tiene que cumplir la igualdad:
ans =
A=U*S*V'
2
>> %Construcción de la pseudoinversa de A o
inversa de Moore-Penrose >> size(A)
>> %Ap=v*Sp*u' ans =
>> %Donde Sp tiene por elementos 3 2
diagonales no nulos los inversos de
>> %n=rango
>> %los valores singulares
>> M=inv(A'*A)
>> Sp=[1/S(1,1),0,0; 0,1/S(2,2),0]
M=
Sp =
0.6667 -0.3333
0.5774 0 0
-0.3333 0.6667
0 1.0000 0
>> M*A'
>> Ap=V*Sp*U'
ans =
Ap =
0.6667 -0.3333 0.3333
0.6667 -0.3333 0.3333
-0.3333 0.6667 0.3333
-0.3333 0.6667 0.3333
>> Ap
>> %La función pinv (pseudo-inv) nos
proporciona la pseudoinversa: Ap =
 0.6667 -0.3333 0.3333 0 1.0000

-0.3333 0.6667 0.3333 0 0

>> (M*A')-Ap V=

ans = -0.7071 0.7071

1.0e-15 * -0.7071 -0.7071

0.3331 -0.1665 0.1110 >> rank(A)

-0.0555 0 -0.0555 ans =

>> %Hay una diferencia pequeña (de 10^-15) 2

entre hacer la pseudoinversa
>> %Como el rango es 2 ignoramos la tercera
>> %por el método directo o sabiendo que fila de U
n=r
>> sigma1 = S(1,1)
MÉTODO 3 (En el caso en que A es cuadrada
sigma1 =
e inversible entonces la inversa de Moore-
Penrose es la inversa, y es inmediato 1.7321
comprobar que se verifican estas cuatro
condiciones. ) >> sigma2=S(2,2)

sigma2 =

A*Ap*A = A >> %Metemos la diagonal en dos vectores

Ap*A*Ap = Ap >> u1=U(:,1)

A*Ap Y Ap*A es simétrica u1 =

-0.4082
18. Comprobación de que A es igual a la
suma de matrices de rango 1 -0.4082
>> %Compresión de imágenes
-0.8165
>> A=[1,0; 0,1; 1,1]
>> u2=U(:,2)
A=
u2 =
1 0
0.7071
0 1
-0.7071
1 1
-0.0000
>> [U,S,V] = svd(A)
>> v1=V(:,1)
U=
v1 =
-0.4082 0.7071 -0.5774
-0.7071
-0.4082 -0.7071 -0.5774
-0.7071
-0.8165 -0.0000 0.5774
>> v2=V(:,2)
S=
v2 =
1.7321 0
 0.7071 x=

-0.7071 1 2 3 4 5 6 7 8 9 10 11
12
>> %Hemos metido cada columna en un
vector >> V=vander(x);

>> sigma1*u1*v1' >> V

ans = V=

0.5000 0.5000 1.0e+11 *

0.5000 0.5000 Columns 1 through 9

0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
1.0000 1.0000
0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000

>> sigma2*u2*v2' 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000

ans = 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000

0.0005 0.0001 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000

0.5000 -0.5000 0.0036 0.0006 0.0001 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000

-0.5000 0.5000 0.0198 0.0028 0.0004 0.0001 0.0000 0.0000 0.0000 0.0000 0.0000

0.0859 0.0107 0.0013 0.0002 0.0000 0.0000 0.0000 0.0000 0.0000

-0.0000 0.0000
0.3138 0.0349 0.0039 0.0004 0.0000 0.0000 0.0000 0.0000 0.0000

>> sigma2*u2*v2' 1.0000 0.1000 0.0100 0.0010 0.0001 0.0000 0.0000 0.0000 0.0000

2.8531 0.2594 0.0236 0.0021 0.0002 0.0000 0.0000 0.0000 0.0000

ans =
7.4301 0.6192 0.0516 0.0043 0.0004 0.0000 0.0000 0.0000 0.0000

0.5000 -0.5000
Columns 10 through 12
-0.5000 0.5000 0.0000 0.0000 0.0000

-0.0000 0.0000 0.0000 0.0000 0.0000

0.0000 0.0000 0.0000

>> sigma1*u1*v1' + sigma2*u2*v2'
0.0000 0.0000 0.0000
ans =
0.0000 0.0000 0.0000
1.0000 -0.0000 0.0000 0.0000 0.0000

0 1.0000 0.0000 0.0000 0.0000

0.0000 0.0000 0.0000

1.0000 1.0000
0.0000 0.0000 0.0000
>> sigma1*u1*v1' + sigma2*u2*v2' - A
0.0000 0.0000 0.0000
ans =
0.0000 0.0000 0.0000

1.0e-15 * 0.0000 0.0000 0.0000

-0.5551 -0.2220 >> A1=fliplr(V);

0 -0.3331 >>

-0.3331 -0.3331 >> %devuelve A con sus columnas volteadas

en la dirección izquierda-derecha
19. Cálculo de la pseudoinversa mediante
>> A1
factorizaion QR de una matriz n*m
MÉTODO 1: A1 =
>> x=[1,2,3,4,5,6,7,8,9,10,11,12] 1.0e+11 *
 Columns 1 through 9 ans =
0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
35831808
0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000

0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000

>> 12^7
0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
ans =
0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000

0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000

35831808
0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0001 MÉTODO 1: Función pinv
0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0002 >> %construimos la pseudoinversa con pinv
0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0004
>> Am=pinv(A)
0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0001 0.0010

0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0002 0.0021 Am =

0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0004 0.0043
Columns 1 through 9
Columns 10 through 12 5.3333 -9.9394 5.3333 4.4848 -3.1515 -4.2424 1.2121 4.2121 -0.2424

-7.4397 19.1365 -11.8605 -8.8501 7.1679 8.8371 -2.9562 -9.0199 0.7566

0.0000 0.0000 0.0000
4.1040 -12.5412 9.2993 5.9744 -5.8825 -6.4924 2.6484 6.9200 -0.8414
0.0000 0.0000 0.0000
-1.1722 3.9828 -3.3820 -1.8708 2.2903 2.2563 -1.1362 -2.5476 0.4290

0.0000 0.0000 0.0000 0.1890 -0.6892 0.6462 0.3102 -0.4657 -0.4131 0.2549 0.4986 -0.1109

0.0000 0.0000 0.0000 -0.0173 0.0665 -0.0671 -0.0282 0.0508 0.0410 -0.0304 -0.0530 0.0149

0.0008 -0.0034 0.0036 0.0013 -0.0028 -0.0021 0.0018 0.0029 -0.0010

0.0000 0.0001 0.0005
-0.0000 0.0001 -0.0001 -0.0000 0.0001 0.0000 -0.0000 -0.0001 0.0000
0.0001 0.0006 0.0036
Columns 10 through 12
0.0004 0.0028 0.0198
-4.4848 3.1515 -0.6667
0.0013 0.0107 0.0859
9.6541 -6.8976 1.4719
0.0039 0.0349 0.3138
-7.4808 5.4761 -1.1837
0.0100 0.1000 1.0000
2.7993 -2.1134 0.4645
0.0236 0.2594 2.8531
-0.5605 0.4390 -0.0985
0.0516 0.6192 7.4301
0.0612 -0.0500 0.0115
>> A=A1(:,1:8);
-0.0034 0.0029 -0.0007
>> A
0.0001 -0.0001 0.0000
A=
1 1 1 1 1 1 1 1

1 2 4 8 16 32 64 128
MÉTODO 2: Producto inversa A’*A por A
>> %construyo pseudoinversa invirtiendo la
1 3 9 27 81 243 729 2187
matriz A'*A, nos proporciona una expresión
1 4 16 64 256 1024 4096 16384
explícita
1 5 25 125 625 3125 15625 78125

1 6 36 216 1296 7776 46656 279936 >> Apd=inv(A'*A)*A'

1 7 49 343 2401 16807 117649 823543
Warning: Matrix is close to singular or badly
1 8 64 512 4096 32768 262144 2097152
scaled. Results may be inaccurate. RCOND =
1 9 81 729 6561 59049 531441 4782969

1 10 100 1000 10000 100000 1000000 10000000

2.025094e-19.
1 11 121 1331 14641 161051 1771561 19487171 Apd =
1 12 144 1728 20736 248832 2985984 35831808
Columns 1 through 9
>> A(12,8)
5.3333 -9.9394 5.3333 4.4848 -3.1515 -4.2424 1.2121 4.2121 -0.2424
-7.4397 19.1365 -11.8605 -8.8501 7.1679 8.8371 -2.9562 -9.0199 0.7566
Método 3: Factorización QR
4.1040 -12.5412 9.2993 5.9744 -5.8825 -6.4924 2.6484 6.9200 -0.8414
>> %construimos la pseudoinversa a través de
-1.1722 3.9828 -3.3820 -1.8708 2.2903 2.2563 -1.1362 -2.5476 0.4290 la factorización QR de A, donde Q no es
0.1890 -0.6892 0.6462 0.3102 -0.4657 -0.4131 0.2549 0.4986 -0.1109 cuadrada (es
-0.0173 0.0665 -0.0671 -0.0282 0.0508 0.0410 -0.0304 -0.0530 0.0149
>> %del tamaño de A con columnas
0.0008 -0.0034 0.0036 0.0013 -0.0028 -0.0021 0.0018 0.0029 -0.0010
ortonormales) y R triangular superior
-0.0000 0.0001 -0.0001 -0.0000 0.0001 0.0000 -0.0000 -0.0001 0.0000
cuadrada
Columns 10 through 12
>> %Si A = QR, se tiene A’*A = R’*Q’*Q*R =
-4.4848 3.1515 -0.6667 R’*R.
9.6541 -6.8976 1.4719 >> %Ahora, inv(A’*A)*A’ = inv(R’*R)*R’*Q’ =
-7.4808 5.4761 -1.1837 inv(R) * inv(R’)*R’ * Q’ = inv(R) * Q’.

2.7993 -2.1134 0.4645 >> %Es decir la pseudoinversa será el

producto de la inversa de R por la traspuesta
-0.5605 0.4390 -0.0985
de Q.
0.0612 -0.0500 0.0115
>> [Q,R]=qr(A,0);
-0.0034 0.0029 -0.0007
>> size(A)
0.0001 -0.0001 0.0000

ans = 9.6541 -6.8976 1.4719

-7.4808 5.4761 -1.1837

2.7993 -2.1134 0.4645

12 8
-0.5605 0.4390 -0.0985
>> size(Q)
0.0612 -0.0500 0.0115
ans =
-0.0034 0.0029 -0.0007
12 8 0.0001 -0.0001 0.0000

>> size(R)

ans =
20. Compresión de imágenes
8 8 >>%Leemos la imagen

>> Apq=inv(R)*Q'; >>X=imread('atardecertemplodebood.jpg');

>> Apq >>%Vemos el tamaño

Apq = >> size(X)
Columns 1 through 9 ans =
5.3333 -9.9394 5.3333 4.4848 -3.1515 -4.2424 1.2121 4.2121 -0.2424
683 1024 3
-7.4397 19.1365 -11.8605 -8.8501 7.1679 8.8371 -2.9562 -9.0199 0.7566

4.1040 -12.5412 9.2993 5.9744 -5.8825 -6.4924 2.6484 6.9200 -0.8414 >> X1=X(:,:,1);
-1.1722 3.9828 -3.3820 -1.8708 2.2903 2.2563 -1.1362 -2.5476 0.4290
>> size(X1)
0.1890 -0.6892 0.6462 0.3102 -0.4657 -0.4131 0.2549 0.4986 -0.1109

-0.0173 0.0665 -0.0671 -0.0282 0.0508 0.0410 -0.0304 -0.0530 0.0149

ans =
0.0008 -0.0034 0.0036 0.0013 -0.0028 -0.0021 0.0018 0.0029 -0.0010
683 1024
-0.0000 0.0001 -0.0001 -0.0000 0.0001 0.0000 -0.0000 -0.0001 0.0000

>> max(max(X1))
Columns 10 through 12
ans =
-4.4848 3.1515 -0.6667
 uint8

255 >> axis image

>> %Tenemos aún un tipo de datos

especial (uint8). Lo convertimos a
números en doble

%precisión (de entrada son enteros):

>> A=double(X1);

>> size(A)

ans =

683 1024

>> max(max(A))

ans =

255 >> %La norma de Frobenius de la

matriz A, ysu relación con la traza de
>> min(min(A))
A’*A:
ans =
>> norm(A,'fro')
0
ans =
>> rank(A)
1.1950e+05
ans =
>> tr = trace(A'*A)
683
tr =

1.4280e+10

>> sqrt(tr)

ans =

1.1950e+05
>> imagesc(A)
>> sigma=svd(A);
>> colormap(gray)
 >> norm(A,2) 2513 1881
>> fc180 =
ans =
180*(2513+1881+1)/(2513*1881)
1.0999e+05 fc180 =
0.167359396211471
>> sigma(1)

ans = 22. El error relativo en la norma 2:

>>
1.0999e+05

>> sigma(rank(A))

ans =

6.9977

>> %Representamos la magnitud de los

valores singulares, en escala
logarítmica:
>> semilogy(sigma,'.')

>> title('Valores singulares (escala

logarítmica)')

>> sigma(1) >> E = A-A180;

ans = >>
>> norm(A,2)
1.0999e+05 ans =
>> sigma(50)
2.699672884664772e+05
>> norm(E,2)
ans = ans =
7.219279818786239e+02
1.6587e+03

>> sigma(100) 23. Ecuaciones no lineales

ans = 1.Método Newton(newton):

EJEMPLO 1
902.2733
>>%x^2-3=0
>> sigma(200)
>>%El algoritmo requiere como
ans =
argumentos la función, su derivada,
410.9683
>>%la estimación inicial x0, la
>> %Llevamos a cabo aproximaciones tolerancia y el número máximo de
para k = 10, 50, 100 y 180:
>>%iteraciones (que detiene la
>> k = 10 ejecución del algoritmo cuando no
k= >>% hay convergencia).
10 >>%Primero metemos la primera
ecuacion
21. Factor de compresión
>> size(A) >> fun = @(x) x^2-3
ans =
fun = niter =

function_handle with value: 6

@(x)x^2-3 >> %comprobación a mano del

resultado:
>> dfun = @(x) 2*x
>> %x^2-3=0;x^2=3;x=sqrt(3)
dfun =
>> sqrt(3)
function_handle with value:
ans =
@(x)2*x
1.7321
>> %aplicamos la función de newton
para resolver la ecuacion. Para ello
tenemos que escribir
EJEMPLO 2
>> %la función , su derivada, x0,la
>> fun2 = @(t) t^2-2
tolerancia y el número de iteraciones
fun2 =
>>
[zero,res,niter]=newton(fun,dfun,1,1.e- function_handle with value:
15,100)
@(t)t^2-2
zero =
>> dfun2 = @(t) 2*t
1.7321
dfun2 =
res =
function_handle with value:
4.4409e-16
@(t)2*t
niter
>>
6 [zero,res,niter]=newton(fun2,dfun2,1,1
.e-15,100)
>> %esto nos da
zero =
>> %zero=raiz buscada
1.4142
>> %res=residual que es el último valor
de la función res =

>> %niter=número de iteraciones -4.4409e-16

>> %para sacar la raíz negativa (ya que niter =

tiene grado 2)
6
>> [zero,res,niter]=newton(fun,dfun,-
>>
1,1.e-15,100)
[zero,res,niter]=newton(fun2,dfun2,-
zero = 1,1.e-15,100)

-1.7321 zero =

res = -1.4142

4.4409e-16 res =
 -4.4409e-16 >> fplot(@(x) 0, [-2,2])

niter = Warning: Function behaves unexpectedly on

array inputs. To improve performance,
6
properly vectorize your function to return an
>> %Comprobación: output with the same size and shape as

the input arguments.

>> sqrt(2)
> In
ans matlab.graphics.function.FunctionLine>getFunc
tion
1.4142

2. Método de newton con gráficas

(fzero):
>> %f(x) = exp(-x) – cos(x)

>> fplot(@(x) exp(-x)-cos(x), [-2,2])

>> %La gráfica nos ayuda a ver por

dónde están las soluciones (y así elegir
la estimación inicial x0). Dibujamos la
recta f(x) = 0 para ver con claridad el
corte con el eje x.

>> %f(x) = exp(-x) – cos(x)

>> fplot(@(x) exp(-x)-cos(x), [-2,2])

>> %La gráfica nos ayuda a ver por

dónde están las soluciones (y así elegir In
la estimación inicial x0). Dibujamos la matlab.graphics.function/FunctionLine/updateF
unction

In
matlab.graphics.function.FunctionLine.set.Func
tion_I

In
matlab.graphics.function.FunctionLine.set.Func
tion

In matlab.graphics.function.FunctionLine

In fplot>singleFplot (line 245)

Infplot>@(f)singleFplot(cax,
{f},limits,extraOpts,args) (line 200)

In fplot>vectorizeFplot (line 200)

In fplot (line 166)

recta f(x) = 0 para ver con claridad el
corte con el eje x. >> %aunque salga el error nos dibuja la
funcion en x=0 en naranja
>> fplot(@(x) exp(-x)-cos(x), [-2,2])
>> options = optimset('Display','iter');
>> hold on
>> fzero(fun3,1,options)
Search for an interval around 1 Zero found in the interval [0.68, 1.32]
containing a sign change:
ans =
Func-count a f(a) b
1.2927
f(b) Procedure
>> %Si damos como argumento de
1 1 -0.172423 1 -
llamada un intervalo y no un punto
0.172423 initial interval
facilitamos a fzero el cálculo de la
3 0.971716 -0.18545 solución:
1.02828 -0.158669 search
>> %el intervalo que usamos es el que
5 0.96 -0.190627 1.04 hemos obtenido de la función anterior
-0.152766 search
>> fzero(fun3,[0.6,1.4],options)
7 0.943431 -0.197724
Func-count x f(x)
1.05657 -0.144216 search
Procedure
9 0.92 -0.207301 1.08
2 1.4 0.0766298 initial
-0.131733 search
3 1.22641 -0.0442751
11 0.886863 -0.219901
interpolation
1.11314 -0.113323 search
4 1.28998 -0.00186486
13 0.84 -0.235752 1.16
interpolation
-0.0858533 search
5 1.29271 7.93165e-06
15 0.773726 -0.254021
interpolation
1.22627 -0.0443633 search
6 1.2927 -8.63867e-09
17 0.68 -0.270956 1.32
interpolation
0.0189599 search
7 1.2927 -3.9857e-14
Search for a zero in the interval [0.68,
interpolation
1.32]:
8 1.2927 0
Func-count x f(x)
interpolation
Procedure
Zero found in the interval [0.6, 1.4]
17 1.32 0.0189599 initial
ans =
18 1.27815 -0.00993803
interpolation 1.2927
19 1.29254 -0.000107487 3.Función newtonsys
interpolation >> %Sistemas d ecuaciones no lineales
20 1.2927 2.60936e-08 %Ahora debemos dar como
interpolation argumentos la función (dos funciones
de dos variables) y la correspondiente
21 1.2927 -1.63158e-12
matriz jacobiana J.
interpolation
%La gráfica de las funciones (implícitas)
22 1.2927 0
nos sirve de ayuda:
interpolation
>> %metemos las funciones
>> F1 = @(x,y) x^2 + y^2 -1

F1 =

function_handle with value:

@(x,y)x^2+y^2-1

>> F2= @(x,y) sin(pi*x/2) + y^3

F2 =

function_handle with value:

Warning: Function behaves unexpectedly on
@(x,y)sin(pi*x/2)+y^3 array inputs. To improve performance,

>> fimplicit(F1,':r',[-2 2 -2 2]) properly vectorize your function to return an

output with the same size and shape
Warning: Function behaves unexpectedly on
array inputs. To improve performance, as the input arguments.

properly vectorize your function to return an > In

output with the same size and shape as matlab.graphics.function.ImplicitFunctionLine>g
etFunction
the input arguments.
In
> In matlab.graphics.function/ImplicitFunctionLine/
matlab.graphics.function.ImplicitFunctionLine>g updateFunction
etFunction
In
In matlab.graphics.function.ImplicitFunctionLine.s
matlab.graphics.function/ImplicitFunctionLine/ et.Function_I
updateFunction
In
In matlab.graphics.function.ImplicitFunctionLine.s
matlab.graphics.function.ImplicitFunctionLine.s et.Function
et.Function_I
In matlab.graphics.function.ImplicitFunctionLine
In
matlab.graphics.function.ImplicitFunctionLine.s In fimplicit>singleFimplicit (line 193)
et.Function
In
In matlab.graphics.function.ImplicitFunctionLine fimplicit>@(f)singleFimplicit(cax,f,limits,extraOp
ts,args) (line 152)
In fimplicit>singleFimplicit (line 193)
In fimplicit>vectorizeFimplicit (line 152)
In
fimplicit>@(f)singleFimplicit(cax,f,limits,extraOp In fimplicit (line 126)
ts,args) (line 152)

In fimplicit>vectorizeFimplicit (line 152)

>> hold off
In fimplicit (line 126)
>> x0=[1,1]'
>> hold on
x0 =
>>%hold on sirve para fijar en la grafica
las curvas graficadas sin que 1
desaparezcan
1
>> fimplicit(F2,'--g',[-2 2 -2 2])
>> [x,res,niter] = The method converged at iteration 0
newtonsys(@Ffun,@Jfun,x0,1.e- with residual
15,100)
x=
The method converged at iteration 10
-0.4761
with residual 0.000000e+00
0.8794
The method converged at iteration 0
with residual res =
x= 0
0.4761 niter =
-0.8794 10
res = >> x
0 x=
niter = -0.4761
10 0.8794
>> x >> res
x= res =
0.4761 0
-0.8794 >> niter
>> res niter =
res = 10
0 >> %Si en el algoritmo eliminamos el
punto y coma tras la instrucción x = x
>> niter
+delta podemos ver la evolución de las
niter = iteraciones:

10 >> x0=[1,1]'

>> x0=[-1,-1]' x0 =

x0 = 1

-1 1

-1
>> [x,res,niter] =
newtonsys(@Ffun,@Jfun,x0,1.e-
15,100)
The method converged at iteration 10
with residual 0.000000e+00
>> [x,res,niter] =
newtonsys(@Ffun,@Jfun,x0,1.e-
15,100)
The method converged at iteration 10
with residual 0.000000e+00
The method converged at iteration 0
with residual
 x= 0.476094633757720

0.4761 -0.879396119396223

-0.8794 x=

res = 0.476095822533811

0 -0.879393408989750

niter = x=

10 0.476095822537555

*Evolución de las iteraciones: -0.879393408982743

1
x=
>>
0.476095822537555
>> [x,res,niter] =
-0.879393408982743
newtonsys(@Ffun,@Jfun,x0,1.e-
15,100) The method converged at iteration 10
with residual 0.000000e+00
x=
The method converged at iteration 0
1.166666666666667
with residual x =
0.333333333333333
0.476095822537555
x=
-0.879393408982743
1.654107965104351
res =
-2.081044544531895
0
x=
niter =
0.491534951793648
10
-1.547471873125681
>>
x=
>>
0.259651929490893
>> x
-1.092433364501102
x=
x=
0.476095822537555
0.468848165651264
-0.879393408982743
-0.923330971123170
>> res
x=
res =
0.475056244769916
0
-0.880995134825647
>> niter
x=
niter =
 10 9 28 8.02739e-17 6.11466e-
05 2.55e-08 1.56
>>
Equation solved.
>>
fsolve completed because the vector of
function values is near zero
24. Resolver sistema de ecuaciones as measured by the value of the
Dos incógnitas function tolerance, and
>> %Función fsolve the problem appears regular as
>> options = measured by the gradient.
optimoptions('fsolve','Display','iter'); <stopping criteria details>
>> x0=[1,1]' x=
x0 = 0.4761
1 -0.8794
1 fval =
>> [x,fval]=fsolve(@Ffun,x0,options) 1.0e-08 *
Norm of First-order Trust-region 0.3740
Iteration Func-count f(x) step -0.8142
optimality radius
>> %Para la otra solución:
0 3 5 8
1 >> x0=[-1,-1]'

1 6 1.22893 0.687184 x0 =
0.694 1 -1
2 7 1.22893 1 -1
0.694 1
>> [x,fval]=fsolve(@Ffun,x0,options)
3 10 1.00835 0.25
0.0987 0.25 Norm of First-order Trust-region

4 13 1.00072 0.25 Iteration Func-count f(x) step

0.102 0.25 optimality radius

5 16 0.906499 0.25 0 3 5 8
0.324 0.25 1

6 19 0.0371533 0.625 1 6 1.22893 0.687184

0.286 0.625 0.694 1

7 22 0.000480315 2 7 1.22893 1
0.125407 0.0639 1.56 0.694 1

8 25 2.89699e-08 3 10 1.00835 0.25

0.00795493 0.000478 1.56 0.0987 0.25
 4 13 1.00072 0.25 >> %El método de Newton nos da la
0.102 0.25 solución (1,0,-1) en solo siete
iteraciones:
5 16 0.906499 0.25
0.324 0.25 >> x0= [3/4,1/2,-1/2]'

6 19 0.0371533 0.625 x0 =
0.286 0.625
0.7500
7 22 0.000480315
0.5000
0.125407 0.0639 1.56
-0.5000
8 25 2.89699e-08
0.00795493 0.000478 1.56 >> [x,res,niter] =
newtonsys(@Ffun3d,@Jfun3d,x0,1.e-
9 28 8.02739e-17 6.11466e-
15,100)
05 2.55e-08 1.56
The method converged at iteration 7
Equation solved.
with residual 0.000000e+00
fsolve completed because the vector of
The method converged at iteration 0
function values is near zero
with residual 1.110223e-16
as measured by the value of the
x=
function tolerance, and
1.0000
the problem appears regular as
measured by the gradient. -0.0000
<stopping criteria details> -1.0000
x= res =
-0.4761 0
0.8794 niter =
fval = 7
1.0e-08 * >> %Pedimos los valores de x, res y el
número de iteraciones:
0.3740
>> x
0.8142
x=
25. Sistemas
de 1.0000
ecuaciones
-0.0000
(tres
ecuaciones -1.0000
no lineales
con tres >> res
incógnitas)
res =
>> %Primero metemos las ecuaciones
como funciones en script 0

>> %Ademas de la matriz jacobiana >> niter

niter = the problem appears regular as
measured by the gradient.
7
<stopping criteria details>
>> %Veamos ahora la solución con
fsolve (que no requiere la matriz x=
jacobiana):
1.0000
>> options =
0.0000
optimoptions('fsolve','Display','iter');
-1.0000
>> x,fval]=fsolve(@Ffun3d,x0,options)
fval =
x,fval]=fsolve(@Ffun3d,x0,options)
1.0e-06 *
↑
0.0000
Error: Invalid expression. When calling
a function or indexing a variable, use 0.1859
parentheses. Otherwise, check for -0.0281
mismatched delimiters.
>> %Otra solución es (-1,1,0):
>> [x,fval]=fsolve(@Ffun3d,x0,options)
>> x0=[2,5,3]'
Norm of First-order Trust-region
x0 =
Iteration Func-count f(x) step
optimality radius 2

0 4 2.44141 5
2.44 1 3
1 8 1.28892 1 >> [x,fval]=fsolve(@Ffun3d,x0,options)
3.21 1
Norm of First-order Trust-region
2 12 0.00945865
0.299689 0.222 1 Iteration Func-count f(x) step
optimality radius
3 16 1.1936e-06
0.0322447 0.00242 1 0 4 1685
404 1
4 20 3.53621e-14
0.000431187 4e-07 1 1 8 815.033 1
238 1

2 12 60.5998 2.5
Equation solved. 38.5 2.5

3 13 60.5998 4.18265
fsolve completed because the vector of 38.5 6.25
function values is near zero 4 17 8.74355 1.04566
as measured by the value of the 7.93 1.05
function tolerance, and 5 18 8.74355 2.29181
7.93 2.61
 6 22 2.2009 0.572953 >> %El método de Newton para esa
2.24 0.573 misma estimación inicial x0:

7 23 2.2009 1.2535 >> x

2.24 1.43
The method converged at iteration 11
8 27 0.871163 0.313376 with residual 0.000000e+00
1.44 0.313
The method converged at iteration 0
9 31 0.221681 0.657633 with residual 1.110223e-16
0.895 0.783
x=
10 35 0.0146236
1.0000
0.347072 0.264 0.783
-0.0000
11 39 2.07769e-05
0.0675135 0.00916 0.868 -1.0000
12 43 1.0214e-10 res =
0.00317906 2.02e-05 0.868
0
13 47 2.63368e-21
7.14607e-06 1.03e-10 0.868 niter =

Equation solved. 11

fsolve completed because the vector of >> x0

function values is near zero x0 =
as measured by the value of the 2
function tolerance, and
5
the problem appears regular as
measured by the gradient. 3

<stopping criteria details> >> %Si elegimos un x0 más próximo

(recordemos siempre que la
x= convergencia, si la hay, es local…:
-1.0000 depende del x0 elegido):

1.0000 >> x0=[-2,2,1]'

-0.0000 x0 =

-2

fval = 1

1.0e-10 * >>

-0.0001 >> [x,res,niter] =

newtonsys(@Ffun3d,@Jfun3d,x0,1.e-
0.5132 15,100)
0.0005
 The method converged at iteration 7 r=
with residual 2.065088e-17
3.0000
The method converged at iteration 0
2.0000
with residual 0.000000e+00
1.0000
x=
Poly
-1.000000000000000
Utilice la función poly para obtener un
1.000000000000000 polinomio de sus raíces: p = poly(r). La
función poly es la inversa de la
0.000000000000000 función roots .

res =
>> p = poly(r)
2.065087526346997e-17
p=
niter =
1.0000 -6.0000 11.0000 -6.0000
7
Fzero
>> Utilice la función fzero para encontrar las
raíces de las ecuaciones no lineales.
- Ahora sí: tenemos la solución (-1,1,0). Mientras que la función roots sólo
funciona con polinomios, la
función fzero se aplica más ampliamente a
26. Cálculo de raíces de polinomios. La
los distintos tipos de ecuaciones.
matriz compañera.

Polinomios con raíces reales Polinomios con raíces imaginarias

>>%La función roots de MATLAB nos
proporciona las raíces de un polinomio
p(x) dado por sus coeficientes en la
base de los monomios. Lo hace
calculando los valores propios de la
matriz compañera.
Compan
A = compan (u) devuelve la matriz
compañera correspondiente cuya primera
fila es -u (2: n) / u (1), donde u es un vector
de coeficientes polinomiales. Los valores
propios de compan (u) son las raíces del
polinomio.

En este caso el sistema sí nos deja ver >> p = [1,-15,85,-225,274,-120]

la función, mediante la instrucción
p=
Type roots
1 -15 85 -225 274 -120
r = roots(p) devuelve las raíces del
polinomio representado por p como un >>%Sacamos la matriz compañera:
vector de columna. 
>> Ap = compan(p)
>> %El polinomio con coeficientes c =
[1, -6, 11, -6] tiene las raíces 1,2,3. Ap =
>> c = [1,-6,11,-6]
15 -85 225 -274 120

1 0 0 0 0
c=
0 1 0 0 0
1 -6 11 -6
0 0 1 0 0
>> r=roots(c)
0 0 0 1 0
>>%Se demuestra que, aunque todo el >> A1 = compan(p)
polinomio este multiplicado por un n
A1 =
número la matriz compañera es la misma
15 -85 225 -274 120
>> q=2*p
1 0 0 0 0
q=
0 1 0 0 0
2 -30 170 -450 548 -240
0 0 1 0 0
>> Aq = compan(q)
0 0 0 1 0
Aq =
>> A2 = transpose(A1)
15 -85 225 -274 120
A2 =
1 0 0 0 0
15 1 0 0 0
0 1 0 0 0
-85 0 1 0 0
0 0 1 0 0
225 0 0 1 0
0 0 0 1 0
-274 0 0 0 1
>>%Sacamos los valores propios de la
matriz 120 0 0 0 0
>> eig(Ap) >> A3 = flipud(A2)
ans = A3 =
5.0000 120 0 0 0 0
4.0000 -274 0 0 0 1
3.0000 225 0 0 1 0
2.0000 -85 0 1 0 0
1.0000 15 1 0 0 0
>>%Sacamos las raíces del polinomio q
>> C = fliplr(A3)
>> roots(q)

ans =

5.0000
C=
4.0000
0 0 0 0 120
3.0000

2.0000 1 0 0 0 -274

1.0000 0 1 0 0 225

Transpose 0 0 1 0 -85
Devuelve la transposición no conjugada de
A, es decir, intercambia el índice de fila y 0 0 0 1 15
columna de cada elemento en cuatro
(matriz del libro Trefethen-Bau.)
pasos.
Errores de redondeo entre matriz
compañera y la matriz del texto de
Trefethen-Bau
>>%sacamos los valores propios de ambas
matrices para comparara los errores
>> vpm = eig(A1)
27. Interpolación polinómica.
Interpolación de Lagrange
baricéntrica:
>> %Meto los nodos en dos vectores
>> x =[0;1;2;3]

vpm =
x=
5.0000
0
4.0000
1
3.0000
2
2.0000
3
1.0000
>> x=x'
>> vpt = eig(C)
x=
vpt =
0 1 2 3
1.0000
>> y=[-5;-6;-1;16]
2.0000
y=
3.0000
-5
4.0000
-6
5.0000
-1
>>%Calculamos la norma de 2 de cada
vector formado por los valores propios 16
sacados anteriormente y redondeados, >> y=y'
ordenados según eig
y=
>> vpe1=[5,4,3,2,1]';
-5 -6 -1 16
>> norm(vpe1-vpm,2)/norm(vpe1,2)
>> %Construyo la matriz de Vandermonde
ans = para x
3.9484e-14 >> V = vander(x)
>> vpe2=[1,2,3,4,5]'; V=
>> norm(vpe2-vpt,2)/norm(vpe2,2) 0 0 0 1
ans = 1 1 1 1
6.9197e-14 8 4 2 1

27 9 3 1

>> %La reordeno

>> A = fliplr(V) 1.000000000000000

A= -0.000000000000001

1 0 0 0 -2.000000000000000

1 1 1 1 -5.000000000000000

1 2 4 8 >> p=p'

1 3 9 27 p=

>> %La solución se saca con backslash de 1.000000000000000 -

A\y' 0.000000000000001 -2.000000000000000
-5.000000000000000
>> s=A\y'
>> %comprobamos que se cumple que al
s=
sustituir las x en p nos da y
-5.0000
>> %p se forma con los coeficientes que
-2.0000 están ordenados de arriba

-0.0000 >> %a abajo en el vector s desde x0 a xn-1

1.0000 >> %p=-5-2x-0*x^2+x^3

>> format long >> polyval(p,0)

>> s=A\y' ans =

s= -5

-5.000000000000000 >> polyval(p,1)

-2.000000000000000 ans =

-0.000000000000001 -6.000000000000001

1.000000000000000 >> polyval(p,2)

ans =

-1.000000000000002

>> polyval(p,3)

ans =

Comprobación del polinomio interpolatorio 16

de Lagrange obtenido
>>%Calculamos la función en el punto que
>> %Evaluamos el polinomio para
nos diga el enunciado:
comprobar que lo hemos hecho bien
>>%P.ej: cuánto vale la función en el punto
>> %Primero ordenamos los coeficientes
4 utilizando un polinomio interpolador de
del resultado obtenido
Lagrange:
>> p=sort(s,'descend')
>> polyval(p,4)
p=
ans =
 51 >> %La función polyfit nos da la solución
del sistema de Vandermonde con la V que
nos

Gráfica del polinomio de interpolación:
>> x1=linspace(0,3);
>>
>> % da MATLAB (aunque los números no
sean exactamente los mismos, debido al
procedimiento

>> %Esta función nos da cien puntos >> %que MATLAB use para resolver el
igualmente espaciados, de 0 a 3. sistema…):

>> %Evaluamos el polinomio de >> cq = V\y'

interpolación en esos puntos:
cq =
>> y1=polyval(p,x1);
1.000000000000000
>> size(y1)
0.000000000000000
ans =
-2.000000000000000
1 100
-5.000000000000000
>> %generamos la gráfica
>> %Vamos a evaluar en el punto 2.5.
>> plot(x,y,'o',x1,y1,'-')
>> u = 2.5

u=

2.500000000000000

>> polyval(q,u)

ans =

5.624999999999998

Ajuste polinómico (sin coeficientes del

polinomio interpolante)
>> v = polyinterp(x,y,u)

v=
Ajuste polinómico (con coeficientes del
polinomio interpolante) 5.625000000000000
>> q = polyfit(x,y,3) >> polyval(p,2.5)
q= ans =
1.000000000000000 - 5.624999999999998
0.000000000000002 -1.999999999999993
-5.000000000000005 >> %El valor en el punto x = 4:

>> polyval(q,4)

ans =
 50.999999999999993 0.900000000000000

>> v4 = polyinterp(x,y,4) 0.950000000000000

v4 = 1.000000000000000

51 1.050000000000000

>> 1.100000000000000

1.150000000000000

Interpolación de Lagrange 1.200000000000000

baricéntrica
Nos permite saber el valor del polinomio 1.250000000000000
en un punto determinado que pertenezca a 1.300000000000000
un intervalo dado pero no conocer el
polinomio interpolatorio 1.350000000000000

>> %metemos los datos 1.400000000000000

>> data = [1,16; 2,18; 3,21; 4,17; 5,15; 6,12] 1.450000000000000

data = 1.500000000000000

1 16 1.550000000000000

2 18 1.600000000000000

3 21 1.650000000000000

4 17 1.700000000000000

5 15 1.750000000000000

6 12 1.800000000000000

1.850000000000000

>> %meto un intervalo que recoja los 1.900000000000000

puntos en los que quiero estudiar el 1.950000000000000
polinomio
2.000000000000000
>> %o nodos de interpolación
2.050000000000000
>> u = 0.75:0.05:6.25;
2.100000000000000
>> %y paso ese vector a columna como los
datos 2.150000000000000

>> ux=u' 2.200000000000000

ux = 2.250000000000000
0.750000000000000
2.300000000000000
0.800000000000000
2.350000000000000
0.850000000000000
2.400000000000000
2.450000000000000 4.000000000000000

2.500000000000000 4.050000000000000

2.550000000000000 4.100000000000000

2.600000000000000 4.150000000000000

2.650000000000000 4.199999999999999

2.700000000000000 4.250000000000000

2.750000000000000 4.300000000000000

2.800000000000000 4.350000000000000

2.850000000000000 4.400000000000000

2.900000000000000 4.450000000000000

2.950000000000000 4.500000000000000

3.000000000000000 4.550000000000000

3.050000000000000 4.600000000000000

3.100000000000000 4.650000000000000

3.150000000000000 4.700000000000000

3.200000000000000 4.750000000000000

3.250000000000000 4.800000000000000

3.300000000000000 4.850000000000000

3.350000000000000 4.900000000000000

3.400000000000000 4.950000000000000

3.450000000000000 5.000000000000000

3.500000000000000 5.050000000000000

3.550000000000000 5.100000000000000

3.600000000000000 5.150000000000000

3.650000000000000 5.200000000000000

3.700000000000000 5.250000000000000

3.750000000000000 5.300000000000000

3.800000000000000 5.350000000000000

3.850000000000000 5.400000000000000

3.900000000000000 5.450000000000000

3.950000000000000 5.500000000000000
 5.550000000000000 14.624256000000001

5.600000000000000 14.511840820312500

5.650000000000000 14.474350250000002

5.700000000000000 14.503692960937498

5.750000000000000 14.592191999999999

5.800000000000000 14.732575726562503

5.850000000000000 14.917968749999998

5.900000000000000 15.141882867187501

5.950000000000000 15.398207999999999

6.000000000000000 15.681203132812497

6.050000000000000 15.985487250000002

6.100000000000000 16.306030273437500

6.150000000000000 16.638144000000004

6.200000000000000 16.977473039062495

6.250000000000000 17.319985750000004

>> size(ux) 17.661965179687503

ans =
18.000000000000000
111 1
18.330975445312500
>> %estudio el valor en cada dato y en cada
18.652064249999999
punto
18.960717585937495
>> [p] = barylag(data, ux);
19.254656000000001
>> [p] = barylag(data, ux)

p= 19.531860351562504
20.559448242187496 19.790562750000007
19.335743999999995 20.029237492187502
18.279928507812500 20.246592000000000
17.379773249999996 20.441557757812497
16.623545648437499 20.613281249999996
16.000000000000000 20.761114898437498
15.498368414062501 20.884608000000000
15.108351749999999 20.983497664062494
14.820110554687503 21.057699749999998
21.107299804687500 15.836487750000000

21.132544000000003 15.684889054687501

21.133830070312502 15.547391999999999

21.111698250000003 15.424459320312501

21.066822210937499 15.316406250000000

21.000000000000000 15.223391460937499

20.912144976562502 15.145407999999998

20.804276750000000 15.082274226562502

20.677512117187494 15.033624750000001

20.533056000000006 14.998901367187500

20.372192382812500 14.977343999999999

20.196275249999999 14.967981632812497

20.006719523437500 14.969623250000000

19.804992000000002 14.980848773437497

19.592602289062498 15.000000000000000

19.371093750000000 15.025171539062500

19.142034429687499 15.054201750000001

18.907008000000001 15.084663679687500

18.667604695312498 15.113856000000002

18.425412250000001 15.138793945312500

18.182006835937500 15.156200250000001

17.938943999999996 15.162496085937500

17.697749601562499 15.153791999999999

17.459910749999999 15.125878851562501

17.226866742187500 15.074218750000000

17.000000000000000 14.993935992187499

16.780627007812505 14.879808000000002

16.569989250000003 14.726256257812500

16.369244148437499 14.527337250000000

16.179456000000005 14.276733398437500

16.001586914062500 13.967744000000001
 13.593276164062502

13.145835749999996

12.617518304687499

12.000000000000000

11.284528570312503

10.461914250000007
Evaluación del polinomio de
9.522520710937496
interpolación en los puntos de
8.456255999999996 Chebyshev
>> n=1000
7.252563476562498
n=
Gráfica del polinomio con fórmula
baricéntrica 1000
>>%Primero hay que aclarar que la x son el
>> %meto la funcion a interpolar
numero de datos y que la y son los datos
>> fun = inline('abs(x) + 0.5*x -x.^2')
>> x=data(:,1)
fun =
x=
Inline function:
1
fun(x) = abs(x) + 0.5*x -x.^2
2
>> %calculo de los pesos o puntos de
3
Chebyshev
4
>> x = cos(pi*(0:n)'/n);
5
>> %calculo los valores de los pesos de
6 Chebyshev

>> y=data(:,2) >> f = fun(x);

y= >> %los pesos van a tener los siguientes

valores
16
>> %el primero y ultimo valen 0.5
18
>> %el resto va variando entre 1 y -1
21
>>%estudio el valor del polinomio en una
17 cantidad determinada de puntos, een este
15 caso 5000

12 >>xx = linspace(-1,1,5000)';

>> plot(x,y,'o',ux,p,'-') >> numer=zeros(size(xx));

>> denom=zeros(size(xx));

>> for j=1:n+1

xdiff = xx-x(j); >> %x2=2
p(2)=a0+2a1+4a2+8a3+16a4+32a5
temp = c(j)./xdiff;
>> %x3=3
numer = numer + temp*f(j);
p(3)=a0+3a1+9a2+27a3+81a4+243a5
denom = denom + temp;
>> %Ahora lo evalúo en el resto de datos
end teniendo en cuenta si son derivadas

>> %he restado a cada elemento del vector >> %x0=0 p'(0)=a1
xx el xj
>> %x1=1 p'(1)=a1+2a2+3a3+4a4+5a5
>> ff = numer./denom;
>> %Formo una matriz con las ecuaciones
Gráfica de interpolación en puntos de de la siguiente forma:
Chebyshev
>>A=[p(x0);p'(x0);p(x1);p'(x1)...
>> plot(x,f,'.',xx,ff,'-')
>> A = [1,0,0, 0, 0, 0; 0, 1, 0, 0, 0, 0; 1, 1, 1,
1, 1, 1; 0, 1, 2, 3, 4, 5; 1, 2, 4, 8, 16, 32; 1, 3,
9, 27,81, 243]

A=

1 0 0 0 0 0

0 1 0 0 0 0

1 1 1 1 1 1

0 1 2 3 4 5

1 2 4 8 16 32

1 3 9 27 81 243

Interpolación de Hermite:
>> %Primero evaluo un polinomio estándar
>> %Meto los datos dados en un vector de
del orden
la misma forma que hemos metido las filas
>> %número de datos proporcionados-1, de la matriz
en los diferentes puntos que me dan
>> b=[2,-9,-4,4,44,2]'
>> %p(x)=a5(x-x0)^5+a4(x-x0)^4+...+a0(x-
b=
x0)^0
2
>> %datos:
-9
>> %p(0) = 2, p’(0) = -9, p(1) = -4, p’(1) = 4,
p(2) = 44, p(3) = 2. -4

>> %Evaluo p(x) en los x dados 4

>> %x0=0 p(0)=a0 44

>> %x1=1 p(1)=a0+a1+a2+a3+a4+a5 2

>> %resuelvo con backlash

>> c=A\b

c=

2.0000

-9.0000

18.0000

-45.5000

39.0000

-8.5000

Gráfica del polinomio de Hermite

>> %meto la cantidad de datos en el vetcor 28. Auste polinómico por mínimos
x cuadrados
>> x=[0,1,2,3] Resolviendo las ecuaciones normales.
Si A'*A es simétrica y definida positiva
x=
>> V2
0 1 2 3
V2 =
>> %meto los datos en el vector y
1 -3 9 -27 81 -243 729
>> y=[2,-4,44,2]
1 -2 4 -8 16 -32 64
y=
1 -1 1 -1 1 -1 1
2 -4 44 2
1 0 0 0 0 0 0
>> %ahora los coeficientes del polinomio
de Hermite en el vector p 1 1 1 1 1 1 1

>> 1 2 4 8 16 32 64

>> p=[-17/2,39,-91/2,18,-9,2] 1 3 9 27 81 243 729

p= >> %nos quedamos con las cuatro primeras

columnas
-8.5000 39.0000 -45.5000 18.0000 -
9.0000 2.0000 >>

>> %represento la grafica en el intervalo u >> A=V2(:,1:4)

>> u=-0.1:0.05:3.1; A=

>> %%la evaluo con la función polyval 1 -3 9 -27

>> v=polyval(p,u); 1 -2 4 -8

>> %represento 1 -1 1 -1

1 0 0 0

1 1 1 1

1 2 4 8
 1 3 9 27 0.0167

>>

>> %metemos los datos dados en un vector

b
Backlash
>> b = [25,7,1,6/5,9/10,15/2,26]' Si el rango es igual al número de columnas

b= >> V2

25.0000 V2 =

7.0000 1 -3 9 -27 81 -243 729

1.0000 1 -2 4 -8 16 -32 64

1.2000 1 -1 1 -1 1 -1 1

0.9000 1 0 0 0 0 0 0

7.5000 1 1 1 1 1 1 1

26.0000 1 2 4 8 16 32 64

>> %Si A'*A es simétrica y definida positiva 1 3 9 27 81 243 729

>> M=A'*A >> %nos quedamos con las cuatro primeras

columnas
M=
>>
7 0 28 0
>> A=V2(:,1:4)
0 28 0 196
A=
28 0 196 0
1 -3 9 -27
0 196 0 1588
1 -2 4 -8
>> c = A'*b
1 -1 1 -1
c=
1 0 0 0
68.6000
1 1 1 1
3.9000
1 2 4 8
518.9000
1 3 9 27
30.9000
>>
>> xn=M\c
>> %metemos los datos dados en un vector
xn =
b
-1.8429
>> b = [25,7,1,6/5,9/10,15/2,26]'
0.0226
b=
2.9107
25.0000
 7.0000 r=

1.0000 1.1643

1.2000 -2.6214

0.9000 -0.0286

7.5000 3.0429

26.0000 -0.2071

>>%Compruebo si el rango es igual al -2.4786

numero de columnas
1.1286
>> rank(A)
>> A'*r
ans =
ans =
4

>> %como el rango es igual al número de

1.0e-12 *
columnas aplico backlash

>> xm = A\b
-0.0142
xm =
-0.0004
-1.8429
-0.0714
0.0226
-0.1066
2.9107

0.0167
Factorización A = QR.
>> V2
Vector proyección de b sobre columnas
V2 =
de A
>> p = A*xm 1 -3 9 -27 81 -243 729
p= 1 -2 4 -8 16 -32 64
23.8357 1 -1 1 -1 1 -1 1
9.6214 1 0 0 0 0 0 0
1.0286 1 1 1 1 1 1 1
-1.8429 1 2 4 8 16 32 64
1.1071 1 3 9 27 81 243 729
9.9786 >> %nos quedamos con las cuatro primeras
columnas
24.8714

Vector residuos >>

>> r = b-p >> A=V2(:,1:4)
A= -2.6458 0 -10.5830 0.0000

1 -3 9 -27 0 5.2915 -0.0000 37.0405

1 -2 4 -8 0 0 9.1652 -0.0000

1 -1 1 -1 0 0 0 14.6969

1 0 0 0 >> size(Q)

1 1 1 1 ans =

1 2 4 8 7 4

1 3 9 27 >> size(R)

>> ans =

>> %metemos los datos dados en un vector 4 4

b
>> %las columnas de Q son ortonormales:
>> b = [25,7,1,6/5,9/10,15/2,26]' Q'*Q=I

b= >> d = Q'*b

25.0000 d=

7.0000 -25.9284

1.0000 0.7370

1.2000 26.6771

0.9000 0.2449

7.5000 >> xqr= R\d

26.0000 xqr =

>>%Resuelvo con factorización QR -1.8429

>> [Q,R]=qr(A,0) 0.0226

Q= 2.9107

-0.3780 -0.5669 0.5455 -0.4082 0.0167

-0.3780 -0.3780 0.0000 0.4082

-0.3780 -0.1890 -0.3273 0.4082 Pseudoinversa

-0.3780 0.0000 -0.4364 -0.0000
-0.3780 0.1890 -0.3273 -0.4082
-0.3780 0.3780 0.0000 -0.4082
-0.3780 0.5669 0.5455 0.4082
R=
>> Ap1 = pinv(A)
Ap1 =
-0.0952 0.1429 0.2857 0.3333
0.2857 0.1429 -0.0952
0.0873 -0.2659 -0.2302 0.0000
0.2302 0.2659 -0.0873
 0.0595 -0.0000 -0.0357 -0.0476 - Matriz de proyección
0.0357 0.0000 0.0595 >>%matriz de proyección

-0.0278 0.0278 0.0278 -0.0000 - >> P1 = A*Ap1

0.0278 -0.0278 0.0278
P1 =
>> Ap2 = inv(A'*A)*A'
0.9286 0.1905 -0.0952 -0.0952
Ap2 = 0.0238 0.0952 -0.0476

-0.0952 0.1429 0.2857 0.3333 0.1905 0.4524 0.3810 0.1429 -

0.2857 0.1429 -0.0952 0.0952 -0.1667 0.0952

0.0873 -0.2659 -0.2302 0 0.2302 -0.0952 0.3810 0.4524 0.2857

0.2659 -0.0873 0.0476 -0.0952 0.0238

0.0595 0 -0.0357 -0.0476 -0.0357 -0.0952 0.1429 0.2857 0.3333

0 0.0595 0.2857 0.1429 -0.0952

-0.0278 0.0278 0.0278 0 -0.0278 0.0238 -0.0952 0.0476 0.2857

-0.0278 0.0278 0.4524 0.3810 -0.0952

>> %Usando la factorización QR de A: 0.0952 -0.1667 -0.0952 0.1429

0.3810 0.4524 0.1905
>> Ap3=inv(R)*Q'
-0.0476 0.0952 0.0238 -0.0952 -
Ap3 =
0.0952 0.1905 0.9286
-0.0952 0.1429 0.2857 0.3333
>> size(P1)
0.2857 0.1429 -0.0952
ans =
0.0873 -0.2659 -0.2302 0.0000
0.2302 0.2659 -0.0873 7 7

0.0595 0.0000 -0.0357 -0.0476 - >> trace(P1)

0.0357 -0.0000 0.0595
ans =
-0.0278 0.0278 0.0278 -0.0000 -
4.0000
0.0278 -0.0278 0.0278
>> %Proyectamos sobre el espacio de
>> %La solución:
columnas de A (de dimensión r = 4).
>> xp = pinv(A)*b
>> %La matriz de proyección (cuadrada de
xp = orden 7) tiene por valores

-1.8429 >> %propios 1,1,1,1,0,0,0.

0.0226 >> eig(P1)

2.9107 ans =

0.0167 0.0000

0.0000

-0.0000

1.0000
 1.0000 0.0238 -0.0952 0.0476 0.2857
0.4524 0.3810 -0.0952
1.0000
0.0952 -0.1667 -0.0952 0.1429
1.0000
0.3810 0.4524 0.1905
>> p = A*xm
-0.0476 0.0952 0.0238 -0.0952 -
p= 0.0952 0.1905 0.9286

23.8357 >> %La matriz de proyección usando la

inversa de A’*A:
9.6214
>> P3 = A*inv(A'*A)*A'
1.0286
P3 =
-1.8429
0.9286 0.1905 -0.0952 -0.0952
1.1071 0.0238 0.0952 -0.0476
9.9786 0.1905 0.4524 0.3810 0.1429 -
24.8714 0.0952 -0.1667 0.0952

>> P1*b -0.0952 0.3810 0.4524 0.2857

0.0476 -0.0952 0.0238
ans =
-0.0952 0.1429 0.2857 0.3333
23.8357 0.2857 0.1429 -0.0952
9.6214 0.0238 -0.0952 0.0476 0.2857
1.0286 0.4524 0.3810 -0.0952

-1.8429 0.0952 -0.1667 -0.0952 0.1429

0.3810 0.4524 0.1905
1.1071
-0.0476 0.0952 0.0238 -0.0952 -
9.9786 0.0952 0.1905 0.9286
24.8714 >> trace(P3)
>> %La matriz de proyección a partir de la ans =
factorización QR de A:
4.0000
>> P2=Q*Q'
>>
P2 =

0.9286 0.1905 -0.0952 -0.0952

0.0238 0.0952 -0.0476

0.1905 0.4524 0.3810 0.1429 - Polyfit

0.0952 -0.1667 0.0952 >> %no necesitamos construir la matriz A.

-0.0952 0.3810 0.4524 0.2857 >> x=[-3,-2,-1,0,1,2,3]

0.0476 -0.0952 0.0238 x=
-0.0952 0.1429 0.2857 0.3333 -3 -2 -1 0 1 2 3
0.2857 0.1429 -0.0952
>> b = [25,7,1,6/5,9/10,15/2,26]'

b=

25.0000

7.0000

1.0000

1.2000

0.9000

7.5000

26.0000

>> y = b' >> %Si aumentamos el grado del polinomio

y=
25.0000 7.0000 1.0000 1.2000
0.9000 7.5000 26.0000
>> pol = polyfit(x,y,3)
pol =
0.0167 2.9107 0.0226 -1.8429
el ajuste es mejor
>> pol5 = polyfit(x,y,5)
pol5 =
-0.0062 0.2295 0.0896 0.7136 -
0.1333 0.5182
>> v5 = polyval(pol5,x);
>> v5 = polyval(pol5,s);

>> plot(x,y,'o',s,v5,'-')
>> %MATLAB ordena los coeficientes de los
polinomios comenzando por el coeficiente
del término de mayor grado

>> cp = fliplr(pol)

cp =

-1.8429 0.0226 2.9107 0.0167

Gráfica con polyfit

>> %dibujamos la gráfica del polinomio

>> s = linspace(-3,3);

>> val = polyval(pol,s);

>> plot(x,y,'o',s,val,'-') >> v6 = polyval(pol6,s);

>> plot(x,y,'o',s,v6,'-')
 >> C

Unrecognized function or variable 'C'.

>> C=A(:,1:2)

C=

1 1

1 4

1 9

1 16

(Caso de interpolación) 1 25

>> %hallo la pseudoinversa (inversa de

Moore-Penrose de A):

>> Ap = pinv(A)

Ap =
29. Problemas de regresión con dos
variables independientes
>> %primero formo la matriz A=t 0.1736 0.1415 0.0881 0.0132 -
>> A=[1,1,3; 1,4,6; 1,9,11; 1,16,18; 1,25,27] 0.0831

A= -0.1870 -0.1509 -0.0907 -0.0065

0.1018
1 1 3
0.1602 0.1322 0.0854 0.0199 -
1 4 6 0.0643
1 9 11 >> Cp = pinv(C)
1 16 18 Cp =
1 25 27 0.4941 0.4059 0.2588 0.0529 -
>> %El rango es r = 2 (se tiene C3 = 2C1 + 0.2118
C2): -0.0267 -0.0187 -0.0053 0.0134
>> rank(A) 0.0374

ans = >> b = [2,3,5,4,2]'

2 b=

>> %C (formada por las columnas C1 y C2 2

de A) sí tiene rango igual al 3
>> %número de columnas. El espacio de 5
columnas de C es el mismo que el
4
>> % de A, y su dimensión es r = 2.
 2 173

>> xm = A\b 205

Warning: Rank deficient, rank = 2, tol = >> v = A'*b

3.876253e-14.
v=
xm =
16
0
173
-1.6521
205
1.6441
>> xm2 = M\v
>> %La solución que nos da MATLAB (xm)
Warning: Matrix is close to singular or
es una solución
badly scaled. Results may be inaccurate.
>> %de las ecuaciones normales (pero no
RCOND = 4.355347e-20.
es la óptima)
xm2 =
>> xm
-14.9734
xm =
-9.1388
0
9.1308
-1.6521
>> M*xm2
1.6441
ans =
>> M = A'*A
16
M=
173
5 55 65
205
55 979 1089
>> M*xm2-v
65 1089 1219
ans =
>> M*xm
0
ans =
0

0
16.0000
>> %La solución óptima (la que tiene
173.0000
norma euclídea mínima) se obtiene
205.0000
>> %como el producto de la pseudoinversa
de A por b:

>> A'*b >> xp = Ap*b

ans = xp =

16 1.0988
 -1.1028 3.2160

1.0947 3.1599

>> %Proyección sobre el espacio de 3.0877

columnas de A. Matriz de proyección.
>> PA = A*Ap
>> pm = A*xm
PA =

0.4674 0.3872 0.2535 0.0663 -

pm = 0.1743

0.3872 0.3310 0.2374 0.1064 -

0.0620
3.2802
0.2535 0.2374 0.2107 0.1733
3.2561
0.1251
3.2160
0.0663 0.1064 0.1733 0.2668
3.1599 0.3872

3.0877 -0.1743 -0.0620 0.1251 0.3872

0.7241
>> xp = Ap*b
>> PC = C*Cp
xp =
PC =
1.0988
0.4674 0.3872 0.2535 0.0663 -
-1.1028 0.1743
1.0947 0.3872 0.3310 0.2374 0.1064 -
>> norm(xm,2) 0.0620

ans = 0.2535 0.2374 0.2107 0.1733

0.1251
2.3308
0.0663 0.1064 0.1733 0.2668
>> norm(xp,2) 0.3872
ans = -0.1743 -0.0620 0.1251 0.3872
1.9031 0.7241

>> %Todas las soluciones (infinitas) nos dan >> p1 = PA*b

el mismo vector de proyección p, p1 =
>> % que es igual a la matriz de proyección 3.2802
P multiplicada por b: p = Pb.
3.2561
>> A*xp
3.2160
ans =
3.1599
3.2802
3.0877
3.2561
>> p2 = PC*b
p2 = 0.0663 0.1064 0.1733 0.2668
0.3872
3.2802
-0.1743 -0.0620 0.1251 0.3872
3.2561
0.7241
3.2160
>> %La matriz de proyección usando la
3.1599 expresión que incluye la inversa de C’*C:

3.0877 >> P4 = C*inv(C'*C)*C'

>> %Usando la factorización QR para C: P4 =

>> C 0.4674 0.3872 0.2535 0.0663 -

0.1743
C=
0.3872 0.3310 0.2374 0.1064 -
1 1 0.0620
1 4 0.2535 0.2374 0.2107 0.1733
1 9 0.1251

1 16 0.0663 0.1064 0.1733 0.2668

0.3872
1 25
-0.1743 -0.0620 0.1251 0.3872
>> [Q,R] = qr(C,0) 0.7241
Q=

-0.4472 -0.5171 Grafica de la superficie de regresión

-0.4472 -0.3620 >> x=[1,2,3,4,5]

-0.4472 -0.1034 x=

-0.4472 0.2585 1 2 3 4 5

-0.4472 0.7239 >> xp

R= xp =

-2.2361 -24.5967 1.0988

0 19.3391 -1.1028

>> P3 = Q*Q' 1.0947

P3 = >> y = [3,3,11/3,9/2,27/5]

0.4674 0.3872 0.2535 0.0663 - y=

0.1743 3.0000 3.0000 3.6667 4.5000
0.3872 0.3310 0.2374 0.1064 - 5.4000
0.0620 >> z = [2,3,5,4,2]
0.2535 0.2374 0.2107 0.1733 z=
0.1251
2 3 5 4 2
>> plot3(x,y,z,'r*') Error de aproximación
>> %el error de aproximación de esta
>> hold on
función se saca:
>> fsurf(@(x,y) xp(1)+xp(2)*x^2+
>> %meto una funcion que sepa que
xp(3)*x*y, [0.5 5.5 0.5 5.5])
derivada va a salir,p.ej la exponencial

>> fun=@(x) exp(x)

fun =

function_handle with value:

@(x)exp(x)

>> %sabemos que su derivada es 1

>> ve = 1

ve =

>> %derivo

>> fs1 = derivNum(0,1,fun)

fs1 =
30. Aproximar la derivada segunda en 1.0862
un punto c.
>> %Metemos la función >> err1 = ve - fs1

>> fun= @(x) x^3 err1 =

fun = -0.0862

function_handle with value: >> %el error es de -0.0862

@(x)x^3 31. La regla de Simpson compuesta

>> %Aplicamos la formula compuesta (con
>> %derivamos
distintos valores de N):
>> fs = derivNum(1,1/10,fun)
>> %meto la funcion
fs =
>> fun = @(x) exp(-x.^2/2)/sqrt(2*pi)
6.0000
fun =
>> %En c=3 la derivada segunda vale:
function_handle with value:
>> fs = derivNum(3,1,fun)
@(x)exp(-x.^2/2)/sqrt(2*pi)
fs =
>> %Tomamos como valor para comparar
18 el dado por la función integral

ç>> ve = integral(fun,0,1)
 0

ve = sol3 =

0.3413 0.3413

>> sol= simpsc(0,1,1,fun) >> sol4= simpsc(0,1,8,fun)

h= h=

1 0.1250

ints = ints =

0 0

sol = sol4 =

0.3415 0.3413

>> sol >> %Al dividir h por dos el error se divide

aproximadamente por 16
sol =
>> %(la expresión del error es R(f) = -( (b-
0.3415
a)*h^4*f^(iv)(x))/2880,
>> ve
>> % donde x es un cierto punto entre a y
ve = b).

0.3413 32. Fórmulas de cuadratura gaussianas

>> %error que se genera es de: Gauss-Legendre
>> syms x
>> error=sol-ve
>> %sacamos las raices con Método de
error = Gauss-Legendre
1.8431e-04 >> roots = vpasolve(legendreP(10,x)==0);
>> sol2= simpsc(0,1,2,fun) >> %las pasamos a doble precisión
h= >> rP=double(roots)
0.5000 rP =
ints = -0.9739
0 -0.8651
sol2 = -0.6794
0.3414 -0.4334
>> sol3= simpsc(0,1,4,fun) -0.1489
h= 0.1489
0.2500 0.4334
ints = 0.6794
 0.8651 ans =

0.9739 2

>> rP=double(roots); >> %Construimos la matriz de Jacobi,

>> %llevamos a cabo el cálculo de los pesos
también con la matriz de Vandermonde
>> %traspuesta (para ello necesitamos
como datos las integrales de los
monomios:
>> % 1, x , x^2,…):
usando las expresiones de los
>> % coeficientes de la relación de
recurrencia: a_k = 0 para todo k;
>> % b_k = k^2/(4 k^2 -1).
>> %primero metemos una matriz 10x10
de zeros

>> V1=vander(rP); >> J = zeros(10,10);

>> A=fliplr(V1); >> J

>> AT = A'; J=

>> %Calculo n=10 integrales de monomios 0 0 0 0 0 0 0 0 0 0

aumnetando el grado( la de
0 0 0 0 0 0 0 0 0 0
1,x,x^2,x^3...,x^8,x^9)
0 0 0 0 0 0 0 0 0 0
>> %mto los resultados en un vector d
0 0 0 0 0 0 0 0 0 0
>> d=[2,0,2/3,0,2/5,0,2/7,0,2/9,0]';
0 0 0 0 0 0 0 0 0 0
>> %resuelvo el sistema
0 0 0 0 0 0 0 0 0 0
>> c = AT\d
0 0 0 0 0 0 0 0 0 0
c=
0 0 0 0 0 0 0 0 0 0
0.0667
0 0 0 0 0 0 0 0 0 0
0.1495
0 0 0 0 0 0 0 0 0 0
0.2191

0.2693
>> %ahora introduciomos las b en la
0.2955
triangular superior a la diagonal
0.2955
>> for i=1:9
0.2693
J(i,i+1) = sqrt(i^2/(4*i^2 - 1));
0.2191
end
0.1495
>> j
0.0667
ans =
>> %aplico las condiciones:
0.0000 + 1.0000i
>> %suma de los pesos igual a 2
>> J
>> sum(c)
J= end

Columns 1 through 8 >> J

0 0.5774 0 0 0 0 J=
0 0
0 0.5774 0 0 0 0
0 0 0.5164 0 0 0 0 0 0 0
0 0
0 0 0.5164 0 0 0
0 0 0 0.5071 0 0 0 0 0 0
0 0
0 0 0 0.5071 0 0
0 0 0 0 0.5040 0 0 0 0 0
0 0
0 0 0 0 0.5040 0
0 0 0 0 0 0.5025 0 0 0 0
0 0
0 0 0 0 0 0.5025
0 0 0 0 0 0 0 0 0 0
0.5017 0
0 0 0 0 0 0
0 0 0 0 0 0 0.5017 0 0 0
0 0.5013
0 0 0 0 0 0
0 0 0 0 0 0 0 0.5013 0 0
0 0
0 0 0 0 0 0
0 0 0 0 0 0 0 0 0.5010 0
0 0
0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0.5008
0 0
0 0 0 0 0 0
Columns 9 through 10 0 0 0 0

0 0 >> %metemos la triangular inferior

0 0 >> for i=1:9

0 0 J(i+1,i) = sqrt(1/(4 - 1/i^2));

0 0 end

0 0 >> J

0 0 J=

0 0 0 0.5774 0 0 0 0
0 0 0 0
0.5010 0
0.5774 0 0.5164 0 0 0
0 0.5008
0 0 0 0
0 0
0 0.5164 0 0.5071 0 0
>> for i=1:9 0 0 0 0

J(i,i+1) = sqrt(i^2/(4*i^2 - 1));

 0 0 0.5071 0 0.5040 0 b0 =
0 0 0 0
2
0 0 0 0.5040 0 0.5025
>> %calculo los pesos usando las primeras
0 0 0 0
componentes al cuadrado
0 0 0 0 0.5025 0
>> %(vi^2)
0.5017 0 0 0
>> for i=1:10
0 0 0 0 0 0.5017
0 0.5013 0 0 w(i)=b0*V(1,i)^2;
0 0 0 0 0 0 end
0.5013 0 0.5010 0
>> %los pesos son igual a :
0 0 0 0 0 0
0 0.5010 0 0.5008 >> w

0 0 0 0 0 0 w=
0 0 0.5008 0 0.0667 0.1495 0.2191 0.2693
>> %los valores propios de J son los nodos 0.2955 0.2955 0.0667 0.1495 0.2191
que necesitamos 0.2693

>> eig(J) >> c'

ans = ans =

-0.9739 0.0667 0.1495 0.2191 0.2693

0.2955 0.2955 0.2693 0.2191 0.1495
-0.8651 0.0667
-0.6794

-0.4334

-0.1489 Chebyshev
Hermite
0.1489

0.9739

0.8651

0.6794

0.4334

>> [V,D]=eig(J);

>> %donde en la matriz D los valores

propios no están ordenados

>> %ahora calculamos los pesos

>> %usando la fórmula de wi=b0*vi1^2 que

para Legendre b0=2

>> b0=2
FUNCIONES
D = diag(v)

Mete el vector v como diagonal de una matriz

D = diag(v,k)

Mete el vector v k veces por denajo de la diagonal de una matriz

L = tril(A)

Saca la matriz inferior de A incluyendo la diagonal

L = tril(A,k)

Saca la matriz inferior de A k veces por debajo de la diagonal

U = triu(A)

Saca la matriz superior de la matriz a con la diagonal

U = triu(A,k)

Saca la matriz superior de A k veces por encima de la diagonal

I = eye(n)

Matriz identidad de dimensión nxn

I = eye(n,m)

Matriz identidad de dimensión n filas m columnas

format short

Hace que los números tengan máximo cuatro decimales

eig(A)

Saca los autovalores de la matriz A

max(abs(eig(A)))

Saca el radio espectral de los autovalores de A

Flipud(A)

Voltear matrices en la dirección vertical

flipr(A)

Devuelve A con sus columnas volteadas en la dirección izquierda-derecha

Polyval

polyval(p,x) devuelve el valor de un polinomio de grado n determinado por

polyfit y evaluado en x.

Polyfit

polyfit(x,y,n) halla los coeficientes de un polinomio p(x) de grado n que

se ajusta a los datos de y minimizando la suma de los cuadrados de las
desviaciones de los datos del modelo (ajuste de mínimos cuadrados).
Plot(X,Y)

crea un gráfico de líneas 2D de los datos de Y frente a los valores

correspondientes de X.

Polyinterp

Se usa en el caso de no tener los coeficientes del polinomio interpolante

Barylag

Realiza una interpolación de lagrange baricéntrica en a para un conjunto

de datos dados

Syms 

permite declarar más de una variable simbólica y no precisa de comillas

simples