alglin.mws

Algebra Lineal con Maple

Maple contiene una libreria dedicada al Algebra Lineal. En esta libreria podemos calcular eingenvalores, eingenvectores, determinantes de matrices, realizar operaciones elementales de filas y columnas, y calcular muchas formas canonicas de matrices. Muchas de estas funciones pueden ser usadas sobre matrices simbolicas.

Para usar esta libreria primero debemos "cargarla". Esto tambien lista los nombres de las funciones que estan disponibles.

> with(linalg);

[BlockDiagonal, GramSchmidt, JordanBlock, LUdecomp,...
[BlockDiagonal, GramSchmidt, JordanBlock, LUdecomp,...
[BlockDiagonal, GramSchmidt, JordanBlock, LUdecomp,...
[BlockDiagonal, GramSchmidt, JordanBlock, LUdecomp,...
[BlockDiagonal, GramSchmidt, JordanBlock, LUdecomp,...
[BlockDiagonal, GramSchmidt, JordanBlock, LUdecomp,...
[BlockDiagonal, GramSchmidt, JordanBlock, LUdecomp,...
[BlockDiagonal, GramSchmidt, JordanBlock, LUdecomp,...
[BlockDiagonal, GramSchmidt, JordanBlock, LUdecomp,...
[BlockDiagonal, GramSchmidt, JordanBlock, LUdecomp,...

Maple usa estructura de arreglo para matrices y vectores. El paquete linalg contiene una pareja de funciones para crear estos objetos.

> a:=vector([2,sin(x),4,5.3,beta]);

a := vector([2, sin(x), 4, 5.3, beta])

> A:=matrix([[1,x,y],[0,1,z],[0,0,1]]);

A := matrix([[1, x, y], [0, 1, z], [0, 0, 1]])

Maple usa el operador &* para denotar multiplicacion matricial no-conmutativa. Debemos usar la funcion evalm para evaluar una expresion matricial.

> evalm(A&*A);

matrix([[1, 2*x, 2*y+x*z], [0, 1, 2*z], [0, 0, 1]])...

Tambien se puede usar el operador exponente en este caso.

> evalm(A^2);

matrix([[1, 2*x, 2*y+x*z], [0, 1, 2*z], [0, 0, 1]])...

Maple puede calcular determinantes:

> det(A);

1

Este resultado es obvio ya que A es una matriz diagonal con unos en su diagonal principal. Podemos tratar con otro problema mas dificil:

> B:=matrix([[a,a,c],[b,5,f],[g,c,d]]);

B := matrix([[a, a, c], [b, 5, f], [g, c, d]])

> det(B);

5*a*d-a*f*c-b*a*d+b*c^2+g*a*f-5*g*c

> inverse(A);

matrix([[1, -x, x*z-y], [0, 1, -z], [0, 0, 1]])

> inverse(B);

matrix([[-(-5*d+f*c)/(5*a*d-a*f*c-b*a*d+b*c^2+g*a*f...
matrix([[-(-5*d+f*c)/(5*a*d-a*f*c-b*a*d+b*c^2+g*a*f...
matrix([[-(-5*d+f*c)/(5*a*d-a*f*c-b*a*d+b*c^2+g*a*f...
matrix([[-(-5*d+f*c)/(5*a*d-a*f*c-b*a*d+b*c^2+g*a*f...
matrix([[-(-5*d+f*c)/(5*a*d-a*f*c-b*a*d+b*c^2+g*a*f...
matrix([[-(-5*d+f*c)/(5*a*d-a*f*c-b*a*d+b*c^2+g*a*f...

En este ultimo calculo suponemos, claramente, que el determinante es diferente de cero.

Maple incluso conoce acerca de la matriz exponencial:

e^A

Esto es util, por ejemplo, en la teoria de los sistemas de ecuaciones diferenciales ordinarias.

> exponential(A);

matrix([[exp(1), x*exp(1), 1/2*x*z*exp(1)+y*exp(1)]...

Un calculo dificil cuando trabajamos con operadores lineales es determinar los eigenvalores y eigenvectores. Maple facilita esto.

> C:=matrix([[2,3],[4,5]]);

C := matrix([[2, 3], [4, 5]])

Primero, calculamos los eigenvalores.

> F:=evalm(C-lambda*array(identity,1..2,1..2));

F := matrix([[2-lambda, 3], [4, 5-lambda]])

> eq1:=det(F);

eq1 := -2-7*lambda+lambda^2

Este es el polinomio caracteriztico. Ahora podemos hallar sus raices.

> egv:=solve(det(F),lambda);

egv := 7/2+1/2*sqrt(57), 7/2-1/2*sqrt(57)

Podemos verificar rapidamente el teorema de Cayley-Hamilton.

> evalm(subs(lambda=C,eq1));

matrix([[0, 0], [0, 0]])

Podemos tambien calcular los eigenvectores para una eigendireccion hallando el espacio nulo del operador

C-I*lambda

para un valor especifico de lambda. El espacio nulo proporciona una base para el nucleo de la matriz.

> nullspace(subs(lambda=egv[1],evalm(F)));

{vector([-3/8+1/8*sqrt(57), 1])}

Maple tiene un comando que calcula los eigenvalores, y otro para calcular el polinomio caracteriztico.

> eigenvals(C);

7/2+1/2*sqrt(57), 7/2-1/2*sqrt(57)

> charpoly(C,lambda);

-2-7*lambda+lambda^2

> eigenvects(C,'radical');

[7/2+1/2*sqrt(57), 1, {vector([-3/8+1/8*sqrt(57), 1...

Cada lista en esta sucesion contiene un eigenvalor, una multiplicidad algebraica, y una eigendireccion. Especificamos la opcion radical para hacer que Maple liste cada eigenvector separadamente, en lugar de usar la funcion RootOf de Maple:

> eigenvects(C);

[7/2+1/2*sqrt(57), 1, {vector([-3/8+1/8*sqrt(57), 1...

Maple puede reducir matrices a muchas formas canonicas.

Primero, calculamos uns matriz entera aleatoria.

> G := array(1..4,1..4):

El proximo paso es crear un numero generador aleatorio para llenar la matriz:

> r:=rand(100):

> for i to 4 do for j to 4 do G[i,j] := r() od od:

> evalm(G);

matrix([[44, 11, 36, 59], [41, 56, 95, 23], [24, 93...

Podemos reducir esta matriz a la forma escalonada por filas usando `gaussjordan`. Podemos extender la matriz con una matriz identidad para obtener la inversa de G.

> H:=extend(G,0,4,0);

H := matrix([[44, 11, 36, 59, 0, 0, 0, 0], [41, 56,...

> for i to 4 do H[i,i+4] := 1 od:

> evalm(H);

matrix([[44, 11, 36, 59, 1, 0, 0, 0], [41, 56, 95, ...

> J:=gaussjord(H);

J := matrix([[1, 0, 0, 0, -211977/4495169, -253095/...

La submatriz de 4x4 del lado derecho debe ser la inversa de G.

> H:=submatrix(J,1..4,5..8);

H := matrix([[-211977/4495169, -253095/4495169, 150...

> evalm(G&*H);

matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [...

Maple puede tambien calcular la forma normal de Jordan y la forma canonica racional. Podemos tambien obtener la matriz de transformacion incluyendo un segundo nombre como un argumento..

> J:=matrix([[34,25],[-16,-6]]);

J := matrix([[34, 25], [-16, -6]])

Aqui obtenemos un solo bloque de Jordan.

> jordan(J,'T1');

matrix([[14, 1], [0, 14]])

Podemos verificar la similaridad usando la transformacion de cambio.

> evalm(T1&*J&*inverse(T1));

matrix([[494, 576], [-400, -466]])

`ratform`, la forma canonica racional trabaja de la misma manera.

> ratform(J,'T2');

matrix([[0, -196], [1, 28]])

> evalm(inverse(T2)&*J&*T2);

matrix([[0, -196], [1, 28]])

Maple contiene un comando para crear matrices de Hilbert.

> C:=hilbert(5);

C := matrix([[1, 1/2, 1/3, 1/4, 1/5], [1/2, 1/3, 1/...

> F:=inverse(C);

F := matrix([[25, -300, 1050, -1400, 630], [-300, 4...

Ya que F tiene todas sus entradas enteras, podemos calcular las formas normal de Smith y Hermite de F.

> ismith(F);

matrix([[5, 0, 0, 0, 0], [0, 60, 0, 0, 0], [0, 0, 4...

> ihermite(F);

matrix([[5, 0, 210, 560, 630], [0, 60, 0, 0, 0], [0...

Nuestro ultimo ejemplo examina la factorizacion de las matrices de Vandermonde y de Toeplitz. Maple tiene un comando que genera ambas matrices.

La funcion vandermonde toma una lista de elementos de un campo y sus argumentos.

> V := vandermonde( [x.(1..4)] );

V := matrix([[1]])

> det(V);

1

> factor(det(V));

1

> T:=toeplitz([x.(1..4)]);

T := matrix([[x.(1 .. 4)]])

> det(T);

x.(1 .. 4)

> factor(det(T));

x.(1 .. 4)