/* [wxMaxima batch file version 1] [ DO NOT EDIT BY HAND! ]*/
/* [ Created with wxMaxima version 0.8.5 ] */

/* [wxMaxima: comment start ]
wxMaxima 0.8.1 http://wxmaxima.sourceforge.net
Maxima 5.19.2 http://maxima.sourceforge.net
Using Lisp GNU Common Lisp (GCL) GCL 2.6.8 (aka GCL)
Distributed under the GNU Public License. See the file COPYING.
Dedicated to the memory of William Schelter.
The function bug_report() provides bug reporting information.
   [wxMaxima: comment end   ] */

/* [wxMaxima: comment start ]
OCW - Universidad de Murcia - Matemáticas - J. Asensio, A. Avilés, S. Sánchez-Pedreño
   [wxMaxima: comment end   ] */

/* [wxMaxima: title   start ]
Práctica 8
Sistemas de ecuaciones lineales. Matrices
Matemáticas
OCW
UNIVERSIDAD DE MURCIA

   [wxMaxima: title   end   ] */

/* [wxMaxima: hide output   ] */
/* [wxMaxima: comment start ]
Despliega cada apartado haciendo click en el cuadrado negro; puedes volver a ocultarlo con otro click.
   [wxMaxima: comment end   ] */

/* [wxMaxima: section start ]
Sistemas de ecuaciones lineales
   [wxMaxima: section end   ] */

/* [wxMaxima: fold    start ] */

/* [wxMaxima: subsect start ]
Sistemas y sus soluciones
   [wxMaxima: subsect end   ] */

/* [wxMaxima: fold    start ] */

/* [wxMaxima: comment start ]
OBSERVACIÓN
Más adelante, en el apartado sobre matrices veremos que la orden nullspace(M) sirve 
para resolver el sistema HOMOGÉNEO
de ecuaciones lineales con matriz de coeficientes M. Para sistemas no homogéneos 
no hay una orden para resolverlos 
en términos de su matriz ampliada, lo cual simplificará 
bastante la introducción de los datos.
   [wxMaxima: comment end   ] */

/* [wxMaxima: comment start ]
SISTEMAS DE ECUACIONES LINEALES
Una posibilidad para resolver sistemas de ecuaciones lineales con wxMaxima 
es utilizar la opción "Solve Linear System" del menú Ecuaciones. Al hacer uso de esta opción 
se abrirá un primer cuadro de diálogo en el que se nos pide el número de ecuaciones y, al 
introducir dicho número, un segundo cuadro en el que se introducirán cada una de las ecuaciones 
en su correspondiente casilla y las incógnitas, separadas por comas, en la casilla adecuada.

Utilizar este procedimiento para discutir y resolver los sistemas 

[  x - 2y +  z + 2t =  1 ]                 Y                [  x +  y +  z =  1 ]
[ 2x +  y + 2z -  t = -3 ]                                  [ 2x - 2y -  z =  0 ]
[  x - 2y + 3z +  t =  4 ]                                  [  x + 3y + 5z =  2 ]
[ 4x - 3y + 6z + 2t =  0 ]                                  

   [wxMaxima: comment end   ] */

/* [wxMaxima: comment start ]
Otra posibilidad es utilizar directamente el comando "linsolve([Ecu1,Ecu2,...],[Incog1,Incog2])" resuelve el sistema de las ecuaciones lineales dadas
en las incógnitas que se indiquen.
                               [ 2x +  y + 2z = 11 ]
Así, para resolver el sistema  [  x + 2y + 2z = -4 ]  hacemos:
                               [  x -  y -  z =  8 ]
   [wxMaxima: comment end   ] */

/* [wxMaxima: hide output   ] */
/* [wxMaxima: input   start ] */
linsolve( [ 2*x+y+2*z=11 , x+2*y+2*z=-4 , x-y-z=8 ] , [x,y,z]);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: comment start ]
EJERCICIO
Observa que la única solución del sistema anterior verifica x+y+z=0.
Abre a continuación una celda de INPUT, copia el sistema anterior añadiendo la ecuación x+y+z=1 
y ejecuta el comando.
¿Cómo interpretas el OUTPUT?
   [wxMaxima: comment end   ] */

/* [wxMaxima: comment start ]
PARÁMETROS
Si la solución es múltiple el sistema asigna parámetros que se van llamando %r1, %r2, ...
                             
Resolver el sistema 
        [ 2x +  y + 2z = 11 ]
        [  x + 2y + 2z = -4 ] 
y comprobar qué se obtiene.
   [wxMaxima: comment end   ] */

/* [wxMaxima: hide output   ] */
/* [wxMaxima: input   start ] */
linsolve([2*x+y+2*z=11, x+2*y+2*z=-4], [x,y,z]);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: comment start ]
OTRA FORMA PARA LOS PARÁMETROS
También se pueden expresar las soluciones en función de las incógnitas (en lugar de asignar parámetros)
asignando el valor "falso" a la variable opcional "linsolve_params". Comprobar el resultado ejecutando los 
siguientes comandos.
   [wxMaxima: comment end   ] */

/* [wxMaxima: hide output   ] */
/* [wxMaxima: input   start ] */
linsolve_params:false$ 
linsolve( [ 2*x+y+2*z+3*t=6 , x+2*y-2*z-t=3 ] , [x,y,z,t]);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: comment start ]
ECUACIONES DEPENDIENTES ELIMINADAS
Si una ecuación "sobra" (lo que equivale a que la correspondiente fila se transforme en un fila de ceros
al aplicar el método de Gauss-Jordan) el sistema lo advierte.
                 [ 2x +  y + 2z + 3t =  6 ]
Así, el sistema  [  x + 2y - 2z -  t =  3 ]  tiene "realmente" 2 ecuaciones y 4 incógnitas (y por tanto 4 parámetros):
                 [ 4x + 5y - 2z +  t = 12 ]
   [wxMaxima: comment end   ] */

/* [wxMaxima: hide output   ] */
/* [wxMaxima: input   start ] */
linsolve( [ 2*x+y+2*z+3*t=6 , x+2*y-2*z-t=3 , 4*x+5*y-2*z+t=12 ] , [x,y,z,t]);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: comment start ]
EJERCICIO
¿Qué harías si te interesara que quedasen despejadas las incógnitas z,t en función de x,y?
   [wxMaxima: comment end   ] */

/* [wxMaxima: fold    end   ] */

/* [wxMaxima: subsect start ]
Sistemas que dependen de parámetros (parámetros en el enunciado)
   [wxMaxima: subsect end   ] */

/* [wxMaxima: fold    start ] */

/* [wxMaxima: comment start ]
EJERCICIO
Interpreta la respuesta a la siguiente orden, en la que los datos del sistema contienen parámetros: a,b,c,d,r,s:
   [wxMaxima: comment end   ] */

/* [wxMaxima: input   start ] */
linsolve( [ a*x+b*y=r , c*x+d*y=s ] , [x,y]);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: comment start ]
A VECES SE ESCAPAN SOLUCIONES
Para estos sistemas que dependen de parámetros, a veces al programa se le escapan soluciones.
                                       [ x +      y      =   1 ]
Por ejemplo, para resolver el sistema  [         ay +  z =   0 ] hacemos:
                                       [ x + (1+a)y + az = 1+a ]
   [wxMaxima: comment end   ] */

/* [wxMaxima: input   start ] */
linsolve( [ x+y=1 , a*y+z=0 , x+(1+a)*y+a*z=1+a ] , [z,y,x]);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: comment start ]
En vista del resultado, hay que suponer que a no vale 1.
Para ver qué pasa cuando a=1, podemos aprovechar lo que ya está escrito (cortar y pegar) haciendo:
   [wxMaxima: comment end   ] */

/* [wxMaxima: hide output   ] */
/* [wxMaxima: input   start ] */
a:1$ 
linsolve( [ x+y=1 , a*y+z=0 , x+(1+a)*y+a*z=1+a ] , [z,y,x]);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: comment start ]
También en vista del resultado parece que la solución es única para cualquier otro valor de a.
Sin embargo, resolviendo a mano se ve que para a=0 el sistema es compatible indeterminado
con 1 grado de libertad. Este caso se le escapa al programa ...
   [wxMaxima: comment end   ] */

/* [wxMaxima: comment start ]
EJERCICIO
Abre una nueva celda de INPUT y comprueba que para a=0 hay solución múltiple (usa adecuadamente cortar y pegar).
   [wxMaxima: comment end   ] */

/* [wxMaxima: fold    end   ] */

/* [wxMaxima: fold    end   ] */

/* [wxMaxima: section start ]
Matrices
   [wxMaxima: section end   ] */

/* [wxMaxima: fold    start ] */

/* [wxMaxima: subsect start ]
Construcción de matrices
   [wxMaxima: subsect end   ] */

/* [wxMaxima: fold    start ] */

/* [wxMaxima: comment start ]
- matrix(Fila1,Fila2,...)                sirve para introducir la matriz fila a fila
- genmatrix(a,NúmFilas,NúmColumnas)      sirve para generar la matriz mediante una fórmula
   [wxMaxima: comment end   ] */

/* [wxMaxima: input   start ] */
matrix( [1,2,%pi] , [5,9,1/2] );
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
kill(a);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
a[i,j]:=i^2+j^2$ genmatrix(a,3,2);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: comment start ]
EJERCICIO
También se pueden utilizar las opciones "Enter Matrix" y "Generate Matrix" del menú "ÃÁlgebra" para introducir y generar
las matrices anteriores.
¡ATENCIÓN! Hazlo cuando aparezca una LÃÍNEA VERTICAL bajo esta celda (haz click o baja con las flechas).
           De lo contrario se abrirá una celda al final del documento.
   [wxMaxima: comment end   ] */

/* [wxMaxima: comment start ]
Para algunos tipos sencillos de matrices hay comandos especiales:

- zeromatrix(Filas,Columnas)            produce una matriz nula del tamaño indicado
- ident(Tamaño)                         produce una matriz cuadrada identidad
- diagmatrix(Tamaño,Escalar)            produce una matriz cuadrada ESCALAR (un escalar por la matriz identidad)
- ematrix(NumF,NumC,Escalar,Fila,Col)   produce una matriz con una única entrada no nula (el escalar en la posición indicada)
- columnvector(Lista)                   produce una matriz columna (hay que cargar un paquete con: load("eigen")
   [wxMaxima: comment end   ] */

/* [wxMaxima: input   start ] */
zeromatrix(2,3);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
ident(3);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
diagmatrix(3,25);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
ematrix(2,3,x,1,2);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
/* Para usar "columnvector" hay que cargar un paquete  */
load("eigen");
columnvector([1,2,3]);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: fold    end   ] */

/* [wxMaxima: subsect start ]
Sumas y productos
   [wxMaxima: subsect end   ] */

/* [wxMaxima: fold    start ] */

/* [wxMaxima: comment start ]
+/-  se usan para sumar y restar matrices. Creamos unas matrices-ejemplo y las operamos:
   [wxMaxima: comment end   ] */

/* [wxMaxima: input   start ] */
A:matrix([1,2,3],[2,3,4]); B:matrix([1,1,1],[2,2,10]);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
A+B; A-B;
/* [wxMaxima: input   end   ] */

/* [wxMaxima: comment start ]
EJERCICIO
Esconde el OUTPUT anterior (¡sólo el último!) para que A y B no te desaparezcan de la pantalla.
Repite esto en el futuro cuando sea necesario.
   [wxMaxima: comment end   ] */

/* [wxMaxima: comment start ]
* (asterisco) se usa para productos "escalar por matriz" o productos "entrada a entrada"
^ (circunflejo) se usa para potencias "entrada a entrada"
  Observa que, por los tamaños, ni A*B ni A^2 tienen sentido para el producto usual de matrices, las 
  operaciones las hace entrada a entrada.
   [wxMaxima: comment end   ] */

/* [wxMaxima: input   start ] */
7*A; A*B;
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
A^2; A^3;
/* [wxMaxima: input   end   ] */

/* [wxMaxima: comment start ]
.  (punto bajo) se usa para multiplicar matrices con el producto usual.
^^ (doble circunflejo) se usa para elevar una matriz cuadrada a una potencia (multiplicarla por sí mismo).
   [wxMaxima: comment end   ] */

/* [wxMaxima: input   start ] */
kill(x)$ C:matrix([1,x],[0,1]); A:matrix([1,2,3],[2,3,4]);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
C.A;
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
C^^2; C^^3;
/* [wxMaxima: input   end   ] */

/* [wxMaxima: comment start ]
EJERCICIO
Escribe en celdas de INPUT las ordenes siguientes, y piensa ANTES DE EJECUTAR qué ocurrirá en cada caso.
A+C; C*A; C^2; C^3; A.B; A^^2;
Recuerda los tamaños de cada una de las matrices: A y B son 3x2 y C es 2x2
   [wxMaxima: comment end   ] */

/* [wxMaxima: fold    end   ] */

/* [wxMaxima: subsect start ]
Manipulaciones sencillas de filas y columnas
   [wxMaxima: subsect end   ] */

/* [wxMaxima: fold    start ] */

/* [wxMaxima: comment start ]
- Matriz(NúmFila,NúmColumna)                              recupera una entrada
- row(Matriz,Fila) o col(Matriz,Columna)                  recupera una fila o columna
- minor(NombreMatriz,FilaElim,ColumnaElim)                elimina una fila y una columna
- submatrix(FilasEl,NombreMatriz,ColumnasEl)              elimina varias filas/columnas
- addrow(Matriz,Fila,Fila,...) o addcol(Matriz,Col,...)   añade filas o columnas
- transpose(NombreMatriz)                                 traspone la matriz (convirtiendo filas en columnas y
                                                          columnas en filas)
   [wxMaxima: comment end   ] */

/* [wxMaxima: input   start ] */
a[i,j]:=i^2 + j^2$ MiMatr:genmatrix(a,3,4);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
MiMatr[3,2];
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
row(MiMatr,3); col(MiMatr,2);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
minor(MiMatr,3,1);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
submatrix(1,MiMatr,2,3);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
addrow(MiMatr,[1,1,1,1]); addcol(MiMatr,[1,1,1],[a,b,c]);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
transpose(MiMatr);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: fold    end   ] */

/* [wxMaxima: subsect start ]
Operaciones elementales; rango y núcleo
   [wxMaxima: subsect end   ] */

/* [wxMaxima: fold    start ] */

/* [wxMaxima: comment start ]
Para algunas de las órdenes que siguen, las versiones más antiguas del programa
requieren tener cargado el paquete "linearalgebra": load("linearalgebra");
   [wxMaxima: comment end   ] */

/* [wxMaxima: comment start ]
- rowswap(Matriz,i,j)     intercambia las filas Fi y Fj
- columnswap(Matriz,i,j)  intercambia las columnas Ci y Cj
- rowop(Matriz,i,j,r)     cambia la fila Fi por la fila Fi-r*Fj
- columnop(Matriz,i,j,r)  cambia la columna Ci por la columna Ci-r*Cj
   [wxMaxima: comment end   ] */

/* [wxMaxima: input   start ] */
/* Ejemplo al que aplicamos las órdenes anteriores */
Mat45:matrix([3,2,1,4,1],[-3,2,7,4,3],[5,2,-1,2,1],[5,6,7,10,5]);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
rowswap(Mat45,2,3); columnswap(%,2,3);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
rowop(Mat45,2,1,-1); columnop(Mat45,4,2,2);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: comment start ]
EJERCICIO
¿Cómo harías para multiplicar una fila por un escalar?
   [wxMaxima: comment end   ] */

/* [wxMaxima: comment start ]
- echelon(Matriz)        calcula una matriz escalonada por filas equivalente por filas a la matriz dada
                         (en general no llega hasta la forma escalonada reducida)
- triangularize(Matriz)  como la anterior, pero sin forzar que los pivotes sean 1
- rank(Matriz)           calcula el rango
   [wxMaxima: comment end   ] */

/* [wxMaxima: input   start ] */
echelon(Mat45); triangularize(Mat45);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
rank(Mat45);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: comment start ]
- nullspace(Matriz)  calcula una base del núcleo de la matriz; es decir unos vectores de forma que las soluciones 
                     del sistema homogéneo con esa matriz de coeficientes se obtienen como combinaciones lienales 
                     a partir de ellos (multiplicando por escalares y sumando); 
                     la respuesta es span(vectores de la base)
   [wxMaxima: comment end   ] */

/* [wxMaxima: input   start ] */
nullspace(Mat45);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: fold    end   ] */

/* [wxMaxima: subsect start ]
Determinantes e inversas
   [wxMaxima: subsect end   ] */

/* [wxMaxima: fold    start ] */

/* [wxMaxima: comment start ]
- determinant(Matriz)    calcula el determinante por operaciones elementales
- adjoint(Matriz)        calcula la traspuesta de la matriz de adjuntos
- invert(Matriz)         calcula la inversa por el método de los adjuntos
- invert(Matriz),detout  el determinante queda fuera como factor común de la inversa
   [wxMaxima: comment end   ] */

/* [wxMaxima: input   start ] */
Mat33:submatrix(3,Mat45,3,5);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
determinant(Mat33);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
adjoint(Mat33);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
invert(Mat33);
/* [wxMaxima: input   end   ] */

/* [wxMaxima: input   start ] */
invert(Mat33),detout;
/* [wxMaxima: input   end   ] */

/* [wxMaxima: comment start ]
EJERCICIO
                                                                                          [ 1   1   1 ]
Calcula el determinante de Vandermonde 3x3 con parámetros a,b,c, o sea el determinante de [ a   b   c ]
                                                                                          [a^2 b^2 c^2]
Puedes seguir estos pasos, abriendo las correspondientes celdas de "input"
(1) borra posibles valores anteriores de a,b,c;
(2) introduce la matriz desde el menú Ã�lgebra -> EnterMatrix; 
(3) calcula el determinante desde el menú Ã�lgebra; ¿es la expresión que conoces?
(4) Factorízala con factor(%), o desde el menú Simplificar -> FactorExpression.
   [wxMaxima: comment end   ] */

/* [wxMaxima: comment start ]
EJERCICIO
                                                                                  [ 1   1   1   1 ]
Repite el ejercicio anterior para el determinante de Vandermonde 4x4, o sea el de [ a   b   c   d ]
                                                                                  [a^2 b^2 c^2 d^2]
                                                                                  [a^3 b^3 c^3 d^3]
   [wxMaxima: comment end   ] */

/* [wxMaxima: fold    end   ] */

/* [wxMaxima: fold    end   ] */

/* Maxima can't load/batch files which end with a comment! */
"Created with wxMaxima"$