| blob | 84b64c4a21a5d807d90024ace34f573218f4392e |
1 @c English version 2011-09-03
2 @menu
3 * Introducción a las matrices y el álgebra lineal::
4 * Funciones y variables para las matrices y el álgebra lineal::
5 @end menu
7 @node Introducción a las matrices y el álgebra lineal, Funciones y variables para las matrices y el álgebra lineal, Matrices y Álgebra Lineal, Matrices y Álgebra Lineal
8 @section Introducción a las matrices y el álgebra lineal
10 @menu
11 * Operador punto::
12 * Vectores::
13 * Paquete eigen::
14 @end menu
16 @node Operador punto, Vectores, Introducción a las matrices y el álgebra lineal, Introducción a las matrices y el álgebra lineal
17 @subsection Operador punto
18 El operador @code{.} realiza la multiplicación matricial y el producto escalar.
19 Cuando los operandos son dos matrices columna o matrices fila @code{a} y @code{b},
20 la expresión @code{a.b} es equivalente a @code{sum (a[i]*b[i], i, 1, length(a))}.
21 Si @code{a} y @code{b} no son complejos, estamos en el caso del producto escalar.
22 En caso de ser @code{a} y @code{b} vectores en el campo complejo, el producto
23 escalar se define como @code{conjugate(a).b}; la función @code{innerproduct} del
24 paquete @code{eigen} realiza el producto escalar complejo.
26 Cuando los operandos son matrices de índole más general,
27 el resultado que se obtiene es el producto matricial de @code{a} por @code{b}.
28 El número de filas de @code{b} debe ser igual al número de columnas de @code{a},
29 y el resultado tiene un número de filas igual al de @code{a} y un número de
30 columnas igual al de @code{b}.
32 Al objeto de distinguir @code{.} como operador aritmético del punto decimal
33 de la notación en coma flotante, puede ser necesario dejar espacios a ambos lados.
34 Por ejemplo, @code{5.e3} es @code{5000.0} pero @code{5 . e3} es @code{5} por @code{e3}.
36 Hay algunas variables globales que controlan la simplificación de expresiones que
37 contengan al operador @code{.}, a saber,
38 @code{dot}, @code{dot0nscsimp}, @code{dot0simp}, @code{dot1simp}, @code{dotassoc},
39 @code{dotconstrules}, @code{dotdistrib}, @code{dotexptsimp}, @code{dotident},
40 y @code{dotscrules}.
42 @node Vectores, Paquete eigen, Operador punto, Introducción a las matrices y el álgebra lineal
43 @subsection Vectores
44 El paquete @code{vect} define funciones para análisis vectorial. Para cargar el paquete en memoria se debe hacer
45 @code{load ("vect")} y con @code{demo ("vect")} se presenta una demostración sobre las funciones del paquete.
46 @c find maxima -name \*orth\* YIELDS NOTHING; ARE THESE FUNCTIONS IN ANOTHER FILE NOW ??
47 @c and SHARE;VECT ORTH contains definitions of various orthogonal curvilinear coordinate systems.
49 El paquete de análisis vectorial puede combinar y simplificar expresiones
50 simbólicas que incluyan productos escalares y vectoriales, junto con los operadores
51 de gradiente, divergencia, rotacional y laplaciano. La distribución de estos operadores
52 sobre sumas o productos se gobierna por ciertas variables, al igual que otras transformaciones,
53 incluida la expansión en componentes en cualquier sistema de coordenadas especificado.
54 También hay funciones para obtener el potencial escalar o vectorial de un campo.
56 El paquete @code{vect} contiene las siguientes funciones:
57 @code{vectorsimp}, @code{scalefactors},
58 @code{express}, @code{potential} y @code{vectorpotential}.
59 @c REVIEW vect.usg TO ENSURE THAT TEXINFO HAS WHATEVER IS THERE
60 @c PRINTFILE(VECT,USAGE,SHARE); for details.
62 Por defecto, el paquete @code{vect} no declara el operador @code{.} como conmutativo.
63 Para transformarlo en conmutativo, se debe ejecutar previamente la instrucción
64 @code{declare(".", commutative)}.
66 @node Paquete eigen, , Vectores, Introducción a las matrices y el álgebra lineal
67 @subsection Paquete eigen
69 El paquete @code{eigen} contiene funciones para el cálculo
70 simbólico de valores y vectores propios. Maxima carga el paquete
71 automáticamente si se hace una llamada a cualquiera de las dos funciones
72 @code{eigenvalues} o @code{eigenvectors}. El paquete se puede cargar de
73 forma explícita mediante @code{load ("eigen")}.
75 La instrucción @code{demo ("eigen")} hace una demostración de las funciones de este paquete;
76 @code{batch ("eigen")} realiza la misma demostración pero sin pausas entre los
77 sucesivos cálculos.
79 Las funciones del paquete @code{eigen} son
80 @code{innerproduct}, @code{unitvector}, @code{columnvector},
81 @code{gramschmidt}, @code{eigenvalues}, @code{eigenvectors}, @code{uniteigenvectors}
82 y @code{similaritytransform}.
84 @c end concepts Matrices and Linear Algebra
85 @node Funciones y variables para las matrices y el álgebra lineal, , Introducción a las matrices y el álgebra lineal, Matrices y Álgebra Lineal
86 @section Funciones y variables para las matrices y el álgebra lineal
88 @deffn {Función} addcol (@var{M}, @var{lista_1}, ..., @var{lista_n})
89 Añade la/s columna/s dada/s por la/s lista/s (o matrices) a la matriz @var{M}.
91 @end deffn
93 @deffn {Función} addrow (@var{M}, @var{lista_1}, ..., @var{lista_n})
94 Añade la/s fila/s dada/s por la/s lista/s (o matrices) a la matriz @var{M}.
96 @end deffn
98 @deffn {Función} adjoint (@var{M})
99 Devuelve el adjunto de la matriz @var{M}.
100 La matriz adjunta es la transpuesta de la matriz de cofactores de @var{M}.
102 @end deffn
104 @deffn {Función} augcoefmatrix ([@var{eqn_1}, ..., @var{eqn_m}], [@var{x_1}, ..., @var{x_n}])
105 Devuelve la matriz aumentada de coeficientes del sistema de ecuaciones lineales
106 @var{eqn_1}, ..., @var{eqn_m} de variables @var{x_1}, ..., @var{x_n}. Se trata de la
107 matriz de coeficientes con una columna adicional para los términos constantes de cada
108 ecuación, es decir, aquellos términos que no dependen de las variables
109 @var{x_1}, ..., @var{x_n}.
111 @example
112 (%i1) m: [2*x - (a - 1)*y = 5*b, c + b*y + a*x = 0]$
113 (%i2) augcoefmatrix (m, [x, y]);
114 [ 2 1 - a - 5 b ]
115 (%o2) [ ]
116 [ a b c ]
117 @end example
119 @end deffn
123 @deffn {Función} cauchy_matrix ([@var{x_1},@var{x_2}, ..., @var{x_m}], [@var{y_1},@var{y_2}, ..., @var{y_n}])
124 @deffnx {Función} cauchy_matrix ([@var{x_1},@var{x_2}, ..., @var{x_n}])
126 Devuelve una matriz de Cauchy @var{n} by @var{m} de elementos
127 @var{a[i,j]} = 1/(@var{x_i}+@var{y_i}).
128 El segundo elemento de @code{cauchy_matrix} es opcional, y en caso
129 de no estar presente, los elementos serán de la forma
130 @var{a[i,j]} = 1/(@var{x_i}+@var{x_j}).
132 Observación: en la literatura, la matriz de Cauchy se define a veces
133 con sus elementos de la forma @var{a[i,j]} = 1/(@var{x_i}-@var{y_i}).
135 Ejemplos:
137 @c ===beg===
138 @c cauchy_matrix([x1,x2],[y1,y2]);
139 @c cauchy_matrix([x1,x2]);
140 @c ===end===
141 @example
142 (%i1) cauchy_matrix([x1,x2],[y1,y2]);
143 [ 1 1 ]
144 [ ------- ------- ]
145 [ y1 + x1 y2 + x1 ]
146 (%o1) [ ]
147 [ 1 1 ]
148 [ ------- ------- ]
149 [ y1 + x2 y2 + x2 ]
151 (%i2) cauchy_matrix([x1,x2]);
152 [ 1 1 ]
153 [ ---- ------- ]
154 [ 2 x1 x2 + x1 ]
155 (%o2) [ ]
156 [ 1 1 ]
157 [ ------- ---- ]
158 [ x2 + x1 2 x2 ]
159 @end example
160 @end deffn
164 @deffn {Función} charpoly (@var{M}, @var{x})
165 Calcula el polinomio característico de la matriz @var{M}
166 respecto de la variable @var{x}. Esto es,
167 @code{determinant (@var{M} - diagmatrix (length (@var{M}), @var{x}))}.
169 @example
170 (%i1) a: matrix ([3, 1], [2, 4]);
171 [ 3 1 ]
172 (%o1) [ ]
173 [ 2 4 ]
174 (%i2) expand (charpoly (a, lambda));
175 2
176 (%o2) lambda - 7 lambda + 10
177 (%i3) (programmode: true, solve (%));
178 (%o3) [lambda = 5, lambda = 2]
179 (%i4) matrix ([x1], [x2]);
180 [ x1 ]
181 (%o4) [ ]
182 [ x2 ]
183 (%i5) ev (a . % - lambda*%, %th(2)[1]);
184 [ x2 - 2 x1 ]
185 (%o5) [ ]
186 [ 2 x1 - x2 ]
187 (%i6) %[1, 1] = 0;
188 (%o6) x2 - 2 x1 = 0
189 (%i7) x2^2 + x1^2 = 1;
190 2 2
191 (%o7) x2 + x1 = 1
192 (%i8) solve ([%th(2), %], [x1, x2]);
193 1 2
194 (%o8) [[x1 = - -------, x2 = - -------],
195 sqrt(5) sqrt(5)
197 1 2
198 [x1 = -------, x2 = -------]]
199 sqrt(5) sqrt(5)
200 @end example
202 @end deffn
204 @deffn {Función} coefmatrix ([@var{eqn_1}, ..., @var{eqn_m}], [@var{x_1}, ..., @var{x_n}])
205 Devuelve la matriz de coeficientes para las variables @var{x_1}, ..., @var{x_n}
206 del sistema de ecuaciones lineales @var{eqn_1}, ..., @var{eqn_m}.
208 @example
209 (%i1) coefmatrix([2*x-(a-1)*y+5*b = 0, b*y+a*x = 3], [x,y]);
210 [ 2 1 - a ]
211 (%o1) [ ]
212 [ a b ]
213 @end example
215 @end deffn
217 @deffn {Función} col (@var{M}, @var{i})
218 Devuelve la @var{i}-ésima columna de la matriz @var{M}.
219 El resultado es una matriz de una sola columna.
220 @c EXAMPLE HERE
222 @end deffn
224 @deffn {Función} columnvector (@var{L})
225 @deffnx {Función} covect (@var{L})
226 Devuelve una matriz con una columna y @code{length (@var{L})} filas,
227 conteniendo los elementos de la lista @var{L}.
229 La llamada @code{covect} es un sinónimo de @code{columnvector}.
231 Es necesario cargar la función haciendo @code{load ("eigen")}.
234 Ejemplo:
236 @c HMM, SPURIOUS "redefining the Macsyma function".
237 @c LEAVE IT HERE SINCE THAT'S WHAT A USER ACTUALLY SEES.
238 @example
239 (%i1) load ("eigen")$
240 Warning - you are redefining the Macsyma function eigenvalues
241 Warning - you are redefining the Macsyma function eigenvectors
242 (%i2) columnvector ([aa, bb, cc, dd]);
243 [ aa ]
244 [ ]
245 [ bb ]
246 (%o2) [ ]
247 [ cc ]
248 [ ]
249 [ dd ]
250 @end example
252 @end deffn
255 @deffn {Función} copymatrix (@var{M})
256 Devuelve una copia de la matriz @var{M}. Esta es la única
257 manera de obtener una réplica de @var{M} además de la de
258 copiar elemento a elemento.
260 Nótese que una asignación de una matriz a otra, como en @code{m2: m1},
261 no hace una copia de @code{m1}. Asignaciones del tipo @code{m2 [i,j]: x} o
262 @code{setelmx (x, i, j, m2} también modifica @code{m1 [i,j]}. Si se crea una copia
263 con @code{copymatrix} y luego se hacen asignaciones se tendrá una copia separada y
264 modificada.
266 @c NEED EXAMPLE HERE
267 @end deffn
269 @deffn {Función} determinant (@var{M})
270 Calcula el determinante de @var{M} por un método similar al
271 de eliminación de Gauss
273 @c JUST HOW DOES ratmx AFFECT THE RESULT ??
274 La forma del resultado depende del valor asignado
275 a @code{ratmx}.
277 @c IS A SPARSE DETERMINANT SOMETHING OTHER THAN THE DETERMINANT OF A SPARSE MATRIX ??
278 Existe una rutina especial para calcular determinantes de matrices con elementos dispersas, la cual
279 será invocada cuando las variables @code{ratmx} y @code{sparse} valgan ambas
280 @code{true}.
282 @c EXAMPLES NEEDED HERE
283 @end deffn
285 @defvr {Variable opcional} detout
286 Valor por defecto: @code{false}
288 Cuando @code{detout} vale @code{true}, el determinante de la matriz
289 cuya inversa se calcula aparece como un factor fuera de la matriz.
291 Para que esta variable surta efecto, @code{doallmxops} y @code{doscmxops} deberían tener
292 el valor @code{false} (véanse sus descripciones). Alternativamente, esta
293 variable puede ser suministrada a @code{ev}.
295 Ejemplo:
297 @example
298 (%i1) m: matrix ([a, b], [c, d]);
299 [ a b ]
300 (%o1) [ ]
301 [ c d ]
302 (%i2) detout: true$
303 (%i3) doallmxops: false$
304 (%i4) doscmxops: false$
305 (%i5) invert (m);
306 [ d - b ]
307 [ ]
308 [ - c a ]
309 (%o5) ------------
310 a d - b c
311 @end example
312 @c THERE'S MORE TO THIS STORY: detout: false$ invert (m); RETURNS THE SAME THING.
313 @c IT APPEARS THAT doallmxops IS CRUCIAL HERE.
315 @end defvr
317 @deffn {Función} diagmatrix (@var{n}, @var{x})
318 Devuelve una matriz diagonal de orden @var{n}
319 con los elementos de la diagonal todos ellos iguales a @var{x}. La llamada
320 @code{diagmatrix (@var{n}, 1)} devuelve una matriz identidad
321 (igual que @code{ident (@var{n})}).
323 La variable @var{n} debe ser un número entero, en caso contrario @code{diagmatrix} envía un mensaje de error.
325 @var{x} puede ser cualquier tipo de expresión, incluso otra matriz.
326 Si @var{x} es una matriz, no se copia; todos los elementos de la diagonal son iguales a @var{x}.
328 @c NEED EXAMPLE HERE
329 @end deffn
331 @defvr {Variable opcional} doallmxops
332 Valor por defecto: @code{true}
334 Cuando @code{doallmxops} vale @code{true},
335 todas las operaciones relacionadas con matrices son
336 llevadas a cabo. Cuando es @code{false}, entonces las
337 selecciones para @code{dot} controlan las operaciones a ejecutar.
339 @c NEED EXAMPLES HERE
340 @end defvr
342 @defvr {Variable opcional} domxexpt
343 Valor por defecto: @code{true}
345 Cuando @code{domxexpt} vale @code{true},
346 un exponente matricial, como @code{exp (@var{M})} donde @var{M} es
347 una matriz, se interpreta como una matriz cuyo elemento @code{[i,j} es
348 igual a @code{exp (m[i,j])}. En otro caso, @code{exp (@var{M})} se
349 evalúa como @code{exp (ev(@var{M}))}.
351 La variable @code{domxexpt} afecta a todas las expresiones de la forma @code{@var{base}^@var{exponente}}
352 donde @var{base} es una expresión escalar o constante y @var{exponente} es una
353 lista o matriz.
355 Ejemplo:
357 @example
358 (%i1) m: matrix ([1, %i], [a+b, %pi]);
359 [ 1 %i ]
360 (%o1) [ ]
361 [ b + a %pi ]
362 (%i2) domxexpt: false$
363 (%i3) (1 - c)^m;
364 [ 1 %i ]
365 [ ]
366 [ b + a %pi ]
367 (%o3) (1 - c)
368 (%i4) domxexpt: true$
369 (%i5) (1 - c)^m;
370 [ %i ]
371 [ 1 - c (1 - c) ]
372 (%o5) [ ]
373 [ b + a %pi ]
374 [ (1 - c) (1 - c) ]
375 @end example
377 @end defvr
379 @defvr {Variable opcional} domxmxops
380 Valor por defecto: @code{true}
382 Cuando @code{domxmxops} vale @code{true}, se realizan todas las operaciones entre
383 matrices o entre matrices y listas (pero no las operaciones
384 entre matrices y escalares); si esta variable es @code{false} tales
385 operaciones no se realizan.
386 @c IS THIS AN EVALUATION OR A SIMPLIFICATION FLAG ??
388 @c NEED EXAMPLE HERE
389 @end defvr
391 @defvr {Variable opcional} domxnctimes
392 Valor por defecto: @code{false}
394 Cuando @code{domxnctimes} vale @code{true}, se calculan los productos
395 no conmutativos entre matrices.
396 @c IS THIS AN EVALUATION OR A SIMPLIFICATION FLAG ??
398 @c NEED EXAMPLE HERE
399 @end defvr
401 @defvr {Variable opcional} dontfactor
402 Valor por defecto: @code{[]}
404 En @code{dontfactor} puede guardarse una lista de variables respecto de
405 las cuales no se realizarán factorizaciones. Inicialmente, la lista
406 está vacía.
408 @end defvr
410 @defvr {Variable opcional} doscmxops
411 Valor por defecto: @code{false}
413 Cuando @code{doscmxops} vale @code{true}, se realizan las operaciones entre escalares y
414 matrices.
415 @c IS THIS AN EVALUATION OR A SIMPLIFICATION FLAG ??
417 @c NEED EXAMPLE HERE
418 @end defvr
420 @defvr {Variable opcional} doscmxplus
421 Valor por defecto: @code{false}
423 Cuando @code{doscmxplus} vale @code{true}, las operaciones entre
424 escalares y matrices dan como resultado una matriz.
425 @c IS THIS AN EVALUATION OR A SIMPLIFICATION FLAG ??
427 @c NEED EXAMPLE HERE
428 @end defvr
430 @defvr {Variable opcional} dot0nscsimp
431 Valor por defecto: @code{true}
433 @c WHAT DOES THIS MEAN EXACTLY ??
434 (Esta descripción no está clara en la versión inglesa original.)
436 @c NEED EXAMPLE HERE
437 @end defvr
440 @c AQUI FALTA DEFINICION DE dot0simp
442 @c AQUI FALTA DEFINICION DE dot1simp
444 @defvr {Variable opcional} dotassoc
445 Valor por defecto: @code{true}
447 Cuando @code{dotassoc} vale @code{true}, una expresión como @code{(A.B).C} se transforma en
448 @code{A.(B.C)}.
449 @c "." MEANS NONCOMMUTATIVE MULTIPLICATION RIGHT ??
451 @c NEED EXAMPLE HERE
452 @end defvr
454 @defvr {Variable opcional} dotconstrules
455 Valor por defecto: @code{true}
457 Cuando @code{dotconstrules} vale @code{true}, un producto no conmutativo de una
458 constante con otro término se transforma en un producto conmutativo.
460 @c NEED EXAMPLE HERE
461 @end defvr
463 @defvr {Variable opcional} dotdistrib
464 Valor por defecto: @code{false}
466 Cuando @code{dotdistrib} vale @code{true}, una expresión como @code{A.(B + C)} se transforma en @code{A.B + A.C}.
468 @c NEED EXAMPLE HERE
469 @end defvr
471 @defvr {Variable opcional} dotexptsimp
472 Valor por defecto: @code{true}
474 Cuando @code{dotexptsimp} vale @code{true}, una expresión como @code{A.A} se transforma en @code{A^^2}.
476 @c NEED EXAMPLE HERE
477 @end defvr
479 @defvr {Variable opcional} dotident
480 Valor por defecto: 1
482 El valor de la variable @code{dotident} es el resultado devuelto por @code{X^^0}.
483 @c "RETURNED" ?? IS THIS A SIMPLIFICATION OR AN EVALUATION ??
485 @c NEED EXAMPLE HERE
486 @end defvr
488 @defvr {Variable opcional} dotscrules
489 Valor por defecto: @code{false}
491 Cuando @code{dotscrules} vale @code{true}, una expresión como @code{A.SC} o @code{SC.A} se transforma
492 en @code{SC*A} y @code{A.(SC*B)} en @code{SC*(A.B)}.
493 @c HMM, DOES "SC" MEAN "SCALAR" HERE ?? CLARIFY
495 @c NEED EXAMPLE HERE
496 @end defvr
498 @deffn {Función} echelon (@var{M})
499 Devuelve la forma escalonada de la matriz @var{M}, obtenida por eliminación gaussiana.
500 La forma escalonada se calcula a partir de @var{M} mediante operaciones elementales con sus filas,
501 de tal manera que el primer elemento no nulo de cada fila en la matriz
502 resultado es la unidad y que cada elemento de la columna por debajo del primer uno de cada
503 fila sean todos ceros.
505 La función @code{triangularize} también lleva a cabo la eliminación gaussiana, pero no
506 normaliza el primer elemento no nulo de cada fila.
508 Otras funciones, como @code{lu_factor} y @code{cholesky}, también dan como resultados
509 matrices triangularizadas.
511 @c ===beg===
512 @c M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
513 @c echelon (M);
514 @c ===end===
515 @example
516 (%i1) M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
517 [ 3 7 aa bb ]
518 [ ]
519 (%o1) [ - 1 8 5 2 ]
520 [ ]
521 [ 9 2 11 4 ]
522 (%i2) echelon (M);
523 [ 1 - 8 - 5 - 2 ]
524 [ ]
525 [ 28 11 ]
526 [ 0 1 -- -- ]
527 (%o2) [ 37 37 ]
528 [ ]
529 [ 37 bb - 119 ]
530 [ 0 0 1 ----------- ]
531 [ 37 aa - 313 ]
532 @end example
534 @end deffn
536 @deffn {Función} eigenvalues (@var{M})
537 @deffnx {Función} eivals (@var{M})
538 @c eigen.mac IS AUTOLOADED IF eigenvalues OR eigenvectors IS REFERENCED; EXTEND THAT TO ALL FUNCTIONS ??
539 @c EACH FUNCTION INTENDED FOR EXTERNAL USE SHOULD HAVE ITS OWN DOCUMENTATION ITEM
540 Devuelve una lista con dos sublistas. La primera sublista la forman los
541 valores propios de la matriz @var{M} y la segunda sus multiplicidades correspondientes.
543 El nombre @code{eivals} es un sinónimo de @code{eigenvalues}.
545 La función @code{eigenvalues} llama a la función @code{solve} para calcular las raíces
546 del polinomio característico de la matriz. En ocasiones, @code{solve} no
547 podrá encontrar dichas raíces, en cuyo caso otras funciones de este paquete
548 no trabajarán correctamente, a excepción de @code{innerproduct},
549 @code{unitvector}, @code{columnvector} y @code{gramschmidt}.
550 @c WHICH ONES ARE THE FUNCTIONS WHICH DON'T WORK ??
551 @c ACTUALLY IT'S MORE IMPORTANT TO LIST THE ONES WHICH DON'T WORK HERE
552 @c WHAT DOES "will not work" MEAN, ANYWAY ??
554 En algunos casos los valores propios encontrados por @code{solve} serán
555 expresiones complicadas, las cuales se podrán simplificar haciendo uso
556 de otras funciones.
557 @c WHAT ARE THOSE OTHER FUNCTIONS ??
559 El paquete @code{eigen.mac} se carga en memoria de forma automática cuando
560 se invocan @code{eigenvalues} o @code{eigenvectors}. Si @code{eigen.mac} no
561 está ya cargado, @code{load ("eigen")} lo carga. Tras la carga, todas las
562 funciones y variables del paquete estarán activas.
563 @c REFER TO OVERVIEW OF PACKAGE (INCLUDING LIST OF FUNCTIONS) HERE
565 @c NEED EXAMPLES HERE
566 @end deffn
568 @deffn {Función} eigenvectors (@var{M})
569 @deffnx {Función} eivects (@var{M})
571 Calcula los vectores propios de la matriz @var{M}.
572 El resultado devuelto es una lista con dos elementos;
573 el primero está formado por dos listas, la primera con los valores propios
574 de @var{M} y la segunda con sus respectivas multiplicidades, el segundo
575 elemento es una lista de listas de vectores propios, una por
576 cada valor propio, pudiendo haber uno o más vectores propios en cada lista.
578 Tomando la matriz @var{M} como argumento, devuelve una lista de listas,
579 la primera de las cuales es la salida de @code{eigenvalues} y las
580 siguientes son los vectorios propios de la matriz asociados a los
581 valores propios correspondientes. Los vectores propios calculados son los
582 vectores propios por la derecha.
584 El nombre @code{eivects} es un sinónimo de @code{eigenvectors}.
586 El paquete @code{eigen.mac} se carga en memoria de forma automática cuando
587 se invocan @code{eigenvalues} o @code{eigenvectors}. Si @code{eigen.mac} no
588 está ya cargado, @code{load ("eigen")} lo carga. Tras la carga, todas las
589 funciones y variables del paquete estarán activas.
591 Las variables que afectan a esta función son:
593 @code{nondiagonalizable} toma el valor @code{true} o @code{false} dependiendo
594 de si la matriz no es diagonalizable o diagonalizable tras la ejecución de
595 @code{eigenvectors}.
597 @code{hermitianmatrix}, si vale @code{true}, entonces los vectores propios
598 degenerados de la matriz hermítica son ortogonalizados mediante el
599 algoritmo de Gram-Schmidt.
601 @code{knowneigvals}, si vale @code{true}, entonces el paquete @code{eigen} da por
602 sentado que los valores propios de la matriz son conocidos por el usuario y
603 almacenados en la variable global @code{listeigvals}. @code{listeigvals} debería
604 ser similar a la salida de @code{eigenvalues}.
606 La función @code{algsys} se utiliza aquí para calcular los vectores propios. A
607 veces, @code{algsys} no podrá calcular una solución. En algunos casos, será posible
608 simplificar los valores propios calculándolos en primer lugar con @code{eigenvalues} y
609 luego utilizando otras funciones para simplificarlos. Tras la simplificación,
610 @code{eigenvectors} podrá ser llamada otra vez con la variable @code{knowneigvals}
611 ajustada al valor @code{true}.
613 Véase también @code{eigenvalues}.
615 Ejemplos:
617 Una matriz con un único vector propio por cada valor propio.
619 @c ===beg===
620 @c M1 : matrix ([11, -1], [1, 7]);
621 @c [vals, vecs] : eigenvectors (M1);
622 @c for i thru length (vals[1]) do disp (val[i] = vals[1][i],
623 @c mult[i] = vals[2][i], vec[i] = vecs[i]);
624 @c ===end===
625 @example
626 (%i1) M1 : matrix ([11, -1], [1, 7]);
627 [ 11 - 1 ]
628 (%o1) [ ]
629 [ 1 7 ]
630 (%i2) [vals, vecs] : eigenvectors (M1);
631 (%o2) [[[9 - sqrt(3), sqrt(3) + 9], [1, 1]],
632 [[[1, sqrt(3) + 2]], [[1, 2 - sqrt(3)]]]]
633 (%i3) for i thru length (vals[1]) do disp (val[i] = vals[1][i],
634 mult[i] = vals[2][i], vec[i] = vecs[i]);
635 val = 9 - sqrt(3)
636 1
638 mult = 1
639 1
641 vec = [[1, sqrt(3) + 2]]
642 1
644 val = sqrt(3) + 9
645 2
647 mult = 1
648 2
650 vec = [[1, 2 - sqrt(3)]]
651 2
653 (%o3) done
654 @end example
656 Una matriz con dos vectores propios para uno de los valores propios.
658 @c ===beg===
659 @c M1 : matrix ([0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 2, 0], [0, 0, 0, 2]);
660 @c [vals, vecs] : eigenvectors (M1);
661 @c for i thru length (vals[1]) do disp (val[i] = vals[1][i],
662 @c mult[i] = vals[2][i], vec[i] = vecs[i]);
663 @c ===end===
664 @example
665 (%i1) M1 : matrix ([0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 2, 0], [0, 0, 0, 2]);
666 [ 0 1 0 0 ]
667 [ ]
668 [ 0 0 0 0 ]
669 (%o1) [ ]
670 [ 0 0 2 0 ]
671 [ ]
672 [ 0 0 0 2 ]
673 (%i2) [vals, vecs] : eigenvectors (M1);
674 (%o2) [[[0, 2], [2, 2]], [[[1, 0, 0, 0]],
675 [[0, 0, 1, 0], [0, 0, 0, 1]]]]
676 (%i3) for i thru length (vals[1]) do disp (val[i] = vals[1][i],
677 mult[i] = vals[2][i], vec[i] = vecs[i]);
678 val = 0
679 1
681 mult = 2
682 1
684 vec = [[1, 0, 0, 0]]
685 1
687 val = 2
688 2
690 mult = 2
691 2
693 vec = [[0, 0, 1, 0], [0, 0, 0, 1]]
694 2
696 (%o3) done
697 @end example
699 @end deffn
703 @deffn {Función} ematrix (@var{m}, @var{n}, @var{x}, @var{i}, @var{j})
704 Devuelve una matriz de orden @var{m} por @var{n}, con todos sus elementos
705 nulos, excepto el que ocupa la posición @code{[@var{i}, @var{j}]}, que
706 es igual a @var{x}.
708 @end deffn
710 @deffn {Función} entermatrix (@var{m}, @var{n})
711 Devuelve una matriz de orden @var{m} por @var{n}, cuyos elementos
712 son leidos de forma interactiva.
714 Si @var{n} es igual a @var{m}, Maxima pregunta por el tipo de
715 matriz (diagonal, simétrica, antisimétrica o general) y luego por
716 cada elemento. Cada respuesta introducida por el usuario debe terminar
717 con un punto y coma @code{;} o con un signo de dólar @code{$}.
719 Si @var{n} y @var{m} no son iguales, Maxima pregunta
720 por el valor de cada elemento.
722 Los elementos de la matriz pueden ser cualquier tipo de
723 expresión, que en todo caso será evaluada.
724 @code{entermatrix} evalúa sus argumentos.
726 @example
727 (%i1) n: 3$
728 (%i2) m: entermatrix (n, n)$
730 Is the matrix 1. Diagonal 2. Symmetric 3. Antisymmetric
731 4. General
732 Answer 1, 2, 3 or 4 :
733 1$
734 Row 1 Column 1:
735 (a+b)^n$
736 Row 2 Column 2:
737 (a+b)^(n+1)$
738 Row 3 Column 3:
739 (a+b)^(n+2)$
741 Matrix entered.
742 (%i3) m;
743 [ 3 ]
744 [ (b + a) 0 0 ]
745 [ ]
746 (%o3) [ 4 ]
747 [ 0 (b + a) 0 ]
748 [ ]
749 [ 5 ]
750 [ 0 0 (b + a) ]
751 @end example
753 @end deffn
756 @deffn {Función} genmatrix (@var{a}, @var{i_2}, @var{j_2}, @var{i_1}, @var{j_1})
757 @deffnx {Función} genmatrix (@var{a}, @var{i_2}, @var{j_2}, @var{i_1})
758 @deffnx {Función} genmatrix (@var{a}, @var{i_2}, @var{j_2})
759 Devuelve una matriz generada a partir de @var{a}, siendo @code{@var{a}[@var{i_1},@var{j_1}]} el elemento superior izquierdo y @code{@var{a}[@var{i_2},@var{j_2}]} el inferior derecho de la matriz.
760 Aquí @var{a} se declara como una arreglo (creado por @code{array},
761 pero no por @code{make_array}), o un array no declarado, o una función array, o una
762 expresión lambda de dos argumentos.
763 (An array function is created like other functions with @code{:=} or @code{define},
764 but arguments are enclosed in square brackets instead of parentheses.)
766 Si se omite @var{j_1}, entonces se le asigna el valor @var{i_1}. Si tanto @var{j_1} como @var{i_1} se omiten, a las dos variables se le asigna el valor 1.
768 Si un elemento @code{i,j} del arreglo no está definido, se le asignará el elemento simbólico @code{@var{a}[i,j]}.
770 @c ===beg===
771 @c h [i, j] := 1 / (i + j - 1);
772 @c genmatrix (h, 3, 3);
773 @c array (a, fixnum, 2, 2);
774 @c a [1, 1] : %e;
775 @c a [2, 2] : %pi;
776 @c genmatrix (a, 2, 2);
777 @c genmatrix (lambda ([i, j], j - i), 3, 3);
778 @c genmatrix (B, 2, 2);
779 @c ===end===
780 @example
781 (%i1) h [i, j] := 1 / (i + j - 1);
782 1
783 (%o1) h := ---------
784 i, j i + j - 1
785 (%i2) genmatrix (h, 3, 3);
786 [ 1 1 ]
787 [ 1 - - ]
788 [ 2 3 ]
789 [ ]
790 [ 1 1 1 ]
791 (%o2) [ - - - ]
792 [ 2 3 4 ]
793 [ ]
794 [ 1 1 1 ]
795 [ - - - ]
796 [ 3 4 5 ]
797 (%i3) array (a, fixnum, 2, 2);
798 (%o3) a
799 (%i4) a [1, 1] : %e;
800 (%o4) %e
801 (%i5) a [2, 2] : %pi;
802 (%o5) %pi
803 (%i6) genmatrix (a, 2, 2);
804 [ %e 0 ]
805 (%o6) [ ]
806 [ 0 %pi ]
807 (%i7) genmatrix (lambda ([i, j], j - i), 3, 3);
808 [ 0 1 2 ]
809 [ ]
810 (%o7) [ - 1 0 1 ]
811 [ ]
812 [ - 2 - 1 0 ]
813 (%i8) genmatrix (B, 2, 2);
814 [ B B ]
815 [ 1, 1 1, 2 ]
816 (%o8) [ ]
817 [ B B ]
818 [ 2, 1 2, 2 ]
819 @end example
821 @end deffn
823 @deffn {Función} gramschmidt (@var{x})
824 @deffnx {Función} gramschmidt (@var{x}, @var{F})
826 Ejecuta el algoritmo de ortogonalización de Gram-Schmidt sobre @var{x},
827 que puede ser una matriz o una lista de listas. La función
828 @code{gramschmidt} no altera el valor de @var{x}.
829 El producto interno por defecto empleado en @code{gramschmidt} es
830 @code{innerproduct}, o @var{F}, si se ha hecho uso de esta opción.
832 Si @var{x} es una matriz, el algoritmo se aplica a las filas de @var{x}. Si
833 @var{x} es una lista de listas, el algoritmo se aplica a las sublistas,
834 las cuales deben tener el mismo número de miembros. En cualquier caso,
835 el valor devuelto es una lista de listas, cuyas sublistas son ortogonales.
836 @c Falta completar este p'arrafo
838 La función @code{factor} es invocada en cada paso del algoritmo para
839 simplificar resultados intermedios. Como consecuencia, el valor retornado
840 puede contener enteros factorizados.
842 El nombre @code{gschmit} es sinónimo de @code{gramschmidt}.
844 Es necesario cargar la función haciendo @code{load ("eigen")}.
846 Ejemplo:
848 Algoritmo de Gram-Schmidt utilizando el producto interno por defecto.
850 @c ===beg===
851 @c load ("eigen")$
852 @c x: matrix ([1, 2, 3], [9, 18, 30], [12, 48, 60]);
853 @c y: gramschmidt (x);
854 @c map (innerproduct, [y[1], y[2], y[3]], [y[2], y[3], y[1]]);
855 @c ===end===
856 @example
857 (%i1) load ("eigen")$
858 (%i2) x: matrix ([1, 2, 3], [9, 18, 30], [12, 48, 60]);
859 [ 1 2 3 ]
860 [ ]
861 (%o2) [ 9 18 30 ]
862 [ ]
863 [ 12 48 60 ]
864 (%i3) y: gramschmidt (x);
865 2 2 4 3
866 3 3 3 5 2 3 2 3
867 (%o3) [[1, 2, 3], [- ---, - --, ---], [- ----, ----, 0]]
868 2 7 7 2 7 5 5
869 (%i4) map (innerproduct, [y[1], y[2], y[3]], [y[2], y[3], y[1]]);
870 (%o4) [0, 0, 0]
871 @end example
873 Algoritmo de Gram-Schmidt utilizando un producto interno especificado
874 por el usuario.
876 @c ===beg===
877 @c load ("eigen")$
878 @c ip (f, g) := integrate (f * g, u, a, b);
879 @c y : gramschmidt ([1, sin(u), cos(u)], ip), a= -%pi/2, b=%pi/2;
880 @c map (ip, [y[1], y[2], y[3]], [y[2], y[3], y[1]]), a= -%pi/2, b=%pi/2;
881 @c ===end===
882 @example
883 (%i1) load ("eigen")$
884 (%i2) ip (f, g) := integrate (f * g, u, a, b);
885 (%o2) ip(f, g) := integrate(f g, u, a, b)
886 (%i3) y : gramschmidt ([1, sin(u), cos(u)], ip), a= -%pi/2, b=%pi/2;
887 %pi cos(u) - 2
888 (%o3) [1, sin(u), --------------]
889 %pi
890 (%i4) map (ip, [y[1], y[2], y[3]], [y[2], y[3], y[1]]), a= -%pi/2, b=%pi/2;
891 (%o4) [0, 0, 0]
892 @end example
894 @end deffn
897 @deffn {Función} ident (@var{n})
898 Devuelve la matriz identidad de orden @var{n}.
900 @end deffn
902 @deffn {Función} innerproduct (@var{x}, @var{y})
903 @deffnx {Función} inprod (@var{x}, @var{y})
904 Devuelve el producto interior o escalar de @var{x} por @var{y}, que deben ser listas de igual longitud, o ambas matrices columa o fila de igual longitud. El valor devuelto es @code{conjugate (x) . y}, donde @code{.} es el operador de multiplicación no conmutativa.
906 Es necesario cargar la función haciendo @code{load ("eigen")}.
908 El nombre @code{inprod} es sinónimo de @code{innerproduct}.
910 @c NEED EXAMPLE HERE
911 @end deffn
913 @c THIS DESCRIPTION NEEDS WORK
914 @deffn {Función} invert (@var{M})
915 Devuelve la inversa de la matriz @var{M}, calculada por el método del adjunto.
917 La implementación actual no es eficiente para matrices de orden grande.
919 Cuando @code{detout} vale @code{true}, el determinante se deja
920 fuera de la inversa a modo de factor escalar.
922 Los elementos de la matriz inversa no se expanden. Si @var{M} tiene elementos
923 polinómicos, se puede mejorar el aspecto del resultado haciendo
924 @code{expand (invert (m)), detout}.
926 Véase la descripción de @code{^^} (exponente no conmutativo) para
927 información sobre otro método para invertir matrices.
929 @end deffn
932 @deffn {Función} list_matrix_entries (@var{M})
933 Devuelve una lista con todos los elementos de la matriz @var{M}.
935 Ejemplo:
937 @c ===beg===
938 @c list_matrix_entries(matrix([a,b],[c,d]));
939 @c ===end===
940 @example
941 (%i1) list_matrix_entries(matrix([a,b],[c,d]));
942 (%o1) [a, b, c, d]
943 @end example
945 @end deffn
948 @defvr {Variable opcional} lmxchar
949 Valor por defecto: @code{[}
951 La variable @code{lmxchar} guarda el carácter a mostrar como delimitador izquierdo de la matriz.
952 Véase también @code{rmxchar}.
954 Ejemplo:
956 @example
957 (%i1) lmxchar: "|"$
958 (%i2) matrix ([a, b, c], [d, e, f], [g, h, i]);
959 | a b c ]
960 | ]
961 (%o2) | d e f ]
962 | ]
963 | g h i ]
964 @end example
966 @end defvr
968 @deffn {Función} matrix (@var{fila_1}, ..., @var{fila_n})
969 Devuelve una matriz rectangular con las filas @var{fila_1}, ..., @var{fila_n}. Cada fila es una lista de expresiones. Todas las filas deben tener el mismo número de miembros.
971 Las operaciones @code{+} (suma), @code{-} (resta), @code{*} (multiplicación) y @code{/} (división), se llevan a cabo elemento a elemento cuando los operandos son dos matrices, un escalar y una matriz o una matriz con un escalar. La operación @code{^} (exponenciación, equivalente a @code{**}) se lleva cabo también elemento a elemento si los operandos son un escalr y una matriz o uma matriz y un escalar, pero no si los operandos son dos matrices.
973 El producto matricial se representa con el operador de multiplicación no conmutativa @code{.}. El correspondiente operador de exponenciación no conmutativa es @code{^^}. Dada la matriz @code{@var{A}}, @code{@var{A}.@var{A} = @var{A}^^2} y @code{@var{A}^^-1} es la inversa de @var{A}, si existe.
975 Algunas variables controlan la simplificación de expresiones que incluyan estas operaciones: @code{doallmxops}, @code{domxexpt}, @code{domxmxops}, @code{doscmxops} y @code{doscmxplus}.
976 @c CHECK -- WE PROBABLY WANT EXHAUSTIVE LIST HERE
978 Hay otras opciones adicionales relacionadas con matrices:
979 @code{lmxchar}, @code{rmxchar}, @code{ratmx}, @code{listarith}, @code{detout},
980 @code{scalarmatrix} y @code{sparse}.
981 @c CHECK -- WE PROBABLY WANT EXHAUSTIVE LIST HERE
983 Hay también algunas funciones que admiten matrices como argumentos o que devuelven resultados matriciales: @code{eigenvalues}, @code{eigenvectors},
984 @code{determinant},
985 @code{charpoly}, @code{genmatrix}, @code{addcol}, @code{addrow},
986 @code{copymatrix}, @code{transpose}, @code{echelon} y @code{rank}.
987 @c CHECK -- WE PROBABLY WANT EXHAUSTIVE LIST HERE
989 Ejemplos:
991 @itemize @bullet
992 @item
993 Construcción de matrices a partir de listas.
994 @end itemize
995 @example
996 (%i1) x: matrix ([17, 3], [-8, 11]);
997 [ 17 3 ]
998 (%o1) [ ]
999 [ - 8 11 ]
1000 (%i2) y: matrix ([%pi, %e], [a, b]);
1001 [ %pi %e ]
1002 (%o2) [ ]
1003 [ a b ]
1004 @end example
1005 @itemize @bullet
1006 @item
1007 Suma elemento a elemento.
1008 @end itemize
1009 @example
1010 (%i3) x + y;
1011 [ %pi + 17 %e + 3 ]
1012 (%o3) [ ]
1013 [ a - 8 b + 11 ]
1014 @end example
1015 @itemize @bullet
1016 @item
1017 Resta elemento a elemento.
1018 @end itemize
1019 @example
1020 (%i4) x - y;
1021 [ 17 - %pi 3 - %e ]
1022 (%o4) [ ]
1023 [ - a - 8 11 - b ]
1024 @end example
1025 @itemize @bullet
1026 @item
1027 Multiplicación elemento a elemento.
1028 @end itemize
1029 @example
1030 (%i5) x * y;
1031 [ 17 %pi 3 %e ]
1032 (%o5) [ ]
1033 [ - 8 a 11 b ]
1034 @end example
1035 @itemize @bullet
1036 @item
1037 División elemento a elemento.
1038 @end itemize
1039 @example
1040 (%i6) x / y;
1041 [ 17 - 1 ]
1042 [ --- 3 %e ]
1043 [ %pi ]
1044 (%o6) [ ]
1045 [ 8 11 ]
1046 [ - - -- ]
1047 [ a b ]
1048 @end example
1049 @itemize @bullet
1050 @item
1051 Matriz elevada a un exponente escalar, operación elemento a elemento.
1052 @end itemize
1053 @example
1054 (%i7) x ^ 3;
1055 [ 4913 27 ]
1056 (%o7) [ ]
1057 [ - 512 1331 ]
1058 @end example
1059 @itemize @bullet
1060 @item
1061 Base escalar y exponente matricial, operación elemento a elemento.
1062 @end itemize
1063 @example
1064 (%i8) exp(y);
1065 [ %pi %e ]
1066 [ %e %e ]
1067 (%o8) [ ]
1068 [ a b ]
1069 [ %e %e ]
1070 @end example
1071 @itemize @bullet
1072 @item
1073 Base y exponente matriciales. Esta operación no se realiza elemento a elemento.
1074 @c WHAT IS THIS ??
1075 @end itemize
1076 @example
1077 (%i9) x ^ y;
1078 [ %pi %e ]
1079 [ ]
1080 [ a b ]
1081 [ 17 3 ]
1082 (%o9) [ ]
1083 [ - 8 11 ]
1084 @end example
1085 @itemize @bullet
1086 @item
1087 Multiplicación matricial no conmutativa.
1088 @end itemize
1089 @example
1090 (%i10) x . y;
1091 [ 3 a + 17 %pi 3 b + 17 %e ]
1092 (%o10) [ ]
1093 [ 11 a - 8 %pi 11 b - 8 %e ]
1094 (%i11) y . x;
1095 [ 17 %pi - 8 %e 3 %pi + 11 %e ]
1096 (%o11) [ ]
1097 [ 17 a - 8 b 11 b + 3 a ]
1098 @end example
1099 @itemize @bullet
1100 @item
1101 Exponenciación matricial no conmutativa. Una base escalar @var{b} elevada a un exponente matricial @var{M} se lleva a cabo elemento a elemento y por lo tanto @code{b^^m} equivale a @code{b^m}.
1102 @end itemize
1103 @example
1104 (%i12) x ^^ 3;
1105 [ 3833 1719 ]
1106 (%o12) [ ]
1107 [ - 4584 395 ]
1108 (%i13) %e ^^ y;
1109 [ %pi %e ]
1110 [ %e %e ]
1111 (%o13) [ ]
1112 [ a b ]
1113 [ %e %e ]
1114 @end example
1115 @itemize @bullet
1116 @item
1117 Una matriz elevada al exponente -1 con el operador de exponenciación no conmutativa equivale a la matriz inversa, si existe.
1118 @end itemize
1119 @example
1120 (%i14) x ^^ -1;
1121 [ 11 3 ]
1122 [ --- - --- ]
1123 [ 211 211 ]
1124 (%o14) [ ]
1125 [ 8 17 ]
1126 [ --- --- ]
1127 [ 211 211 ]
1128 (%i15) x . (x ^^ -1);
1129 [ 1 0 ]
1130 (%o15) [ ]
1131 [ 0 1 ]
1132 @end example
1134 @end deffn
1136 @deffn {Función} matrixmap (@var{f}, @var{M})
1137 Devuelve una matriz con el elemento @code{i,j} igual a @code{@var{f}(@var{M}[i,j])}.
1139 Véanse también @code{map}, @code{fullmap}, @code{fullmapl} y @code{apply}.
1141 @c NEED EXAMPLE HERE
1142 @end deffn
1144 @deffn {Función} matrixp (@var{expr})
1145 Devuelve @code{true} si @var{expr} es una matriz, en caso contrario @code{false}.
1147 @end deffn
1149 @defvr {Variable opcional} matrix_element_add
1150 Valor por defecto: @code{+}
1152 La variable @code{matrix_element_add} guarda el símbolo del operador a ejecutar en lugar de la suma en el producto matricial; a @code{matrix_element_add} se le puede asignar cualquier operador n-ario (esto es, una función que admite cualquier número de argumentos). El valor asignado puede ser el nombre de un operador encerrado entre apóstrofos, el nombre de una función o una expresión lambda.
1154 Véanse también @code{matrix_element_mult} y @code{matrix_element_transpose}.
1156 Ejemplo:
1158 @example
1159 (%i1) matrix_element_add: "*"$
1160 (%i2) matrix_element_mult: "^"$
1161 (%i3) aa: matrix ([a, b, c], [d, e, f]);
1162 [ a b c ]
1163 (%o3) [ ]
1164 [ d e f ]
1165 (%i4) bb: matrix ([u, v, w], [x, y, z]);
1166 [ u v w ]
1167 (%o4) [ ]
1168 [ x y z ]
1169 (%i5) aa . transpose (bb);
1170 [ u v w x y z ]
1171 [ a b c a b c ]
1172 (%o5) [ ]
1173 [ u v w x y z ]
1174 [ d e f d e f ]
1175 @end example
1177 @end defvr
1180 @defvr {Variable opcional} matrix_element_mult
1181 Valor por defecto: @code{*}
1183 La variable @code{matrix_element_mult} guarda el símbolo del operador a ejecutar en lugar de la multiplicación en el producto matricial; a @code{matrix_element_mult} se le puede asignar cualquier operador binario. El valor asignado puede ser el nombre de un operador encerrado entre apóstrofos, el nombre de una función o una expresión lambda.
1185 El operador @code{.} puede ser una opción útil en determinados contextos.
1187 Véanse también @code{matrix_element_add} y @code{matrix_element_transpose}.
1189 Ejemplo:
1191 @example
1192 (%i1) matrix_element_add: lambda ([[x]], sqrt (apply ("+", x)))$
1193 (%i2) matrix_element_mult: lambda ([x, y], (x - y)^2)$
1194 (%i3) [a, b, c] . [x, y, z];
1195 2 2 2
1196 (%o3) sqrt((c - z) + (b - y) + (a - x) )
1197 (%i4) aa: matrix ([a, b, c], [d, e, f]);
1198 [ a b c ]
1199 (%o4) [ ]
1200 [ d e f ]
1201 (%i5) bb: matrix ([u, v, w], [x, y, z]);
1202 [ u v w ]
1203 (%o5) [ ]
1204 [ x y z ]
1205 (%i6) aa . transpose (bb);
1206 [ 2 2 2 ]
1207 [ sqrt((c - w) + (b - v) + (a - u) ) ]
1208 (%o6) Col 1 = [ ]
1209 [ 2 2 2 ]
1210 [ sqrt((f - w) + (e - v) + (d - u) ) ]
1212 [ 2 2 2 ]
1213 [ sqrt((c - z) + (b - y) + (a - x) ) ]
1214 Col 2 = [ ]
1215 [ 2 2 2 ]
1216 [ sqrt((f - z) + (e - y) + (d - x) ) ]
1217 @end example
1219 @end defvr
1221 @defvr {Variable opcional} matrix_element_transpose
1222 Valor por defecto: @code{false}
1224 La variable @code{matrix_element_transpose} es una operación que se aplica a cada elemento de una matriz a la que se le calcula la transpuesta. A @code{matrix_element_mult} se le puede asignar cualquier operador unitario. El valor asignado puede ser el nombre de un operador encerrador entre apóstrofos, el nombre de una función o una expresión lambda.
1226 Cuando @code{matrix_element_transpose} es igual a @code{transpose}, la función @code{transpose} se aplica a cada elemento. Cuando @code{matrix_element_transpose} es igual a @code{nonscalars}, la función @code{transpose} se aplica a todos los elementos no escalares. Si alguno de los elementos es un átomo, la opción @code{nonscalars} se aplica
1227 @code{transpose} sólo si el átomo se declara no escalar, mientras que la opción @code{transpose} siempre aplica @code{transpose}.
1229 La opción por defecto, @code{false}, significa que no se aplica ninguna operación.
1231 Véanse también @code{matrix_element_add} y @code{matrix_element_mult}.
1233 Ejemplos:
1235 @example
1236 (%i1) declare (a, nonscalar)$
1237 (%i2) transpose ([a, b]);
1238 [ transpose(a) ]
1239 (%o2) [ ]
1240 [ b ]
1241 (%i3) matrix_element_transpose: nonscalars$
1242 (%i4) transpose ([a, b]);
1243 [ transpose(a) ]
1244 (%o4) [ ]
1245 [ b ]
1246 (%i5) matrix_element_transpose: transpose$
1247 (%i6) transpose ([a, b]);
1248 [ transpose(a) ]
1249 (%o6) [ ]
1250 [ transpose(b) ]
1251 (%i7) matrix_element_transpose:
1252 lambda ([x], realpart(x) - %i*imagpart(x))$
1253 (%i8) m: matrix ([1 + 5*%i, 3 - 2*%i], [7*%i, 11]);
1254 [ 5 %i + 1 3 - 2 %i ]
1255 (%o8) [ ]
1256 [ 7 %i 11 ]
1257 (%i9) transpose (m);
1258 [ 1 - 5 %i - 7 %i ]
1259 (%o9) [ ]
1260 [ 2 %i + 3 11 ]
1261 @end example
1263 @end defvr
1266 @c IS THIS THE ONLY MATRIX TRACE FUNCTION ??
1267 @deffn {Función} mattrace (@var{M})
1268 Devuelve la traza (esto es, la suma de los elementos de la diagonal principal) de la matriz cuadrada @var{M}.
1270 Para disponer de esta función es necesario cargar el paquete haciendo @code{load ("nchrpl")}.
1272 @end deffn
1274 @deffn {Función} minor (@var{M}, @var{i}, @var{j})
1275 Devuelve el menor @code{(@var{i}, @var{j})} de la matriz @var{M}. Esto es, la propia matriz @var{M}, una vez extraídas la fila @var{i} y la columna @var{j}.
1277 @end deffn
1281 @deffn {Función} ncharpoly (@var{M}, @var{x})
1282 Devuelve el polinomio característico de la matriz @var{M} respecto de la variable @var{x}. Es una alternativa a la función @code{charpoly} de Maxima.
1284 La función @code{ncharpoly} opera calculando trazas de las potencias de la matriz dada, que son iguales a las sumas de las potencias de las raíces del polinomio característico. A partir de estas cantidades se pueden calcular las funciones simétricas de las raíces, que no son otra cosa sino los coeficientes del polinomio característico. La función @code{charpoly} opera calculando el determinante de by @code{@var{x} * ident [n] - a}. La función @code{ncharpoly} es m'as eficiente en el caso de matrices grandes y densas.
1286 Para disponer de esta función es necesario cargar el paquete haciendo @code{load ("nchrpl")}.
1288 @end deffn
1290 @deffn {Función} newdet (@var{M})
1291 Calcula el determinante de la matriz @var{M} por el algoritmo del árbol menor
1292 de Johnson-Gentleman. El resultado devuelto por @code{newdet} tiene formato CRE.
1293 @end deffn
1297 @deffn {Función} permanent (@var{M})
1298 Calcula la permanente de la matriz @var{M} por el algoritmo del árbol menor de
1299 Johnson-Gentleman. La permanente es como un determinante pero sin cambios de signo.
1300 El resultado devuelto por @code{permanent} tiene formato CRE.
1302 Véase también @code{newdet}.
1304 @end deffn
1306 @deffn {Función} rank (@var{M})
1307 Calcula el rango de la matriz @var{M}. Esto es, el orden del mayor subdeterminante no singular de @var{M}.
1309 @c STATEMENT NEEDS CLARIFICATION
1310 La función @var{rango} puede retornar una respuesta errónea si no detecta que un elemento de la matriz equivalente a cero lo es.
1312 @end deffn
1314 @defvr {Variable opcional} ratmx
1315 Valor por defecto: @code{false}
1317 Si @code{ratmx} vale @code{false}, el determinante y la suma, resta y producto matriciales se calculan cuando las matrices se expresan en términos de sus elementos, pero no se calcula la inversión matricial en su representación general.
1319 Si @code{ratmx} vale @code{true}, las cuatro operaciones citadas más arriba se calculan en el formato CRE y el resultado de la matriz inversa también se da en formato CRE. Esto puede hacer que se expandan los elementos de la matriz, dependiendo del valor de @code{ratfac}, lo que quizás no sea siempre deseable.
1321 @end defvr
1323 @deffn {Función} row (@var{M}, @var{i})
1324 Devuelve la @var{i}-ésima fila de la matriz @var{M}. El valor que devuelve tiene formato de matriz.
1326 @end deffn
1330 @defvr {Variable opcional} rmxchar
1331 Valor por defecto: @code{]}
1333 La variable @code{rmxchar} es el carácter que se dibuja al lado derecho de una matriz.
1335 Véase también @code{lmxchar}.
1337 @end defvr
1341 @defvr {Variable opcional} scalarmatrixp
1342 Valor por defecto: @code{true}
1344 Si @code{scalarmatrixp} vale @code{true}, entonces siempre que una matriz 1 x 1 se produce como resultado del cálculo del producto no conmutativo de matrices se cambia al formato escalar.
1346 Si @code{scalarmatrixp} vale @code{all}, entonces todas las matrices 1 x 1 se simplifican a escalares.
1348 Si @code{scalarmatrixp} vale @code{false}, las matrices 1 x 1 no se convierten en escalares.
1350 @end defvr
1352 @c FALTA AQUI DEFINICION DE scalefactors.
1354 @deffn {Función} setelmx (@var{x}, @var{i}, @var{j}, @var{M})
1355 Asigna el valor @var{x} al (@var{i}, @var{j})-ésimo elemento de la matriz @var{M} y devuelve la matriz actualizada.
1357 La llamada @code{@var{M} [@var{i}, @var{j}]: @var{x}} hace lo mismo, pero devuelve @var{x} en lugar de @var{M}.
1359 @end deffn
1361 @deffn {Función} similaritytransform (@var{M})
1362 @deffnx {Función} simtran (@var{M})
1363 La función @code{similaritytransform} calcula la transformada de similitud de la matriz @code{M}. Devuelve una lista que es la salida de la instrucción @code{uniteigenvectors}. Además, si la variable @code{nondiagonalizable} vale @code{false} entonces se calculan dos matrices globales @code{leftmatrix} y @code{rightmatrix}. Estas matrices tienen la propiedad de que @code{leftmatrix . @var{M} . rightmatrix} es una matriz diagonal con los valores propios de @var{M} en su diagonal. Si @code{nondiagonalizable} vale @code{true} entonces no se calculan estas matrices.
1365 Si la variable @code{hermitianmatrix} vale @code{true} entonces @code{leftmatrix} es el conjugado complejo de la transpuesta de @code{rightmatrix}. En otro caso @code{leftmatrix} es la inversa de @code{rightmatrix}.
1367 Las columnas de la matriz @code{rightmatrix} son los vectores propios de @var{M}. Las otras variables (véanse @code{eigenvalues} y @code{eigenvectors}) tienen el mismo efecto, puesto que @code{similaritytransform} llama a las otras funciones del paquete para poder formar @code{rightmatrix}.
1369 Estas funciones se cargan con @code{load ("eigen")}.
1371 El nombre @code{simtran} es sinónimo de @code{similaritytransform}.
1373 @end deffn
1375 @defvr {Variable opcional} sparse
1376 Valor por defecto: @code{false}
1378 Si @code{sparse} vale @code{true} y si @code{ratmx} vale @code{true}, entonces @code{determinant}
1379 utilizará rutinas especiales para calcular determinantes dispersos.
1381 @end defvr
1383 @deffn {Función} submatrix (@var{i_1}, ..., @var{i_m}, @var{M}, @var{j_1}, ..., @var{j_n})
1384 @deffnx {Función} submatrix (@var{i_1}, ..., @var{i_m}, @var{M})
1385 @deffnx {Función} submatrix (@var{M}, @var{j_1}, ..., @var{j_n})
1386 Devuelve una nueva matriz formada a partir de la matriz @var{M} pero cuyas filas @var{i_1}, ..., @var{i_m} y columnas @var{j_1}, ..., @var{j_n} han sido eliminadas.
1388 @end deffn
1390 @deffn {Función} transpose (@var{M})
1391 Calcula la transpuesta de @var{M}.
1393 Si @var{M} es una matriz, el valor devuelto es otra matriz @var{N} tal que @code{N[i,j] = M[j,i]}.
1395 Si @var{M} es una lista, el valor devuelto es una matriz @var{N} de @code{length (m)} filas y 1 columna, tal que @code{N[i,1] = M[i]}.
1397 En caso de no ser @var{M} ni matriz ni lista, se devuelve la
1398 expresión nominal @code{'transpose (@var{M})}.
1399 @end deffn
1401 @deffn {Función} triangularize (@var{M})
1402 Devuelve la forma triangular superior de la matriz @code{M}, obtenida por eliminación gaussiana.
1403 El resultado es el mismo que el devuelto por @code{echelon}, con la salvedad de que el primer elemento no nulo de cada fila no se normaliza a 1.
1405 Las funciones @code{lu_factor} y @code{cholesky} también triangularizan matrices.
1407 @c ===beg===
1408 @c M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
1409 @c triangularize (M);
1410 @c ===end===
1411 @example
1412 (%i1) M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
1413 [ 3 7 aa bb ]
1414 [ ]
1415 (%o1) [ - 1 8 5 2 ]
1416 [ ]
1417 [ 9 2 11 4 ]
1418 (%i2) triangularize (M);
1419 [ - 1 8 5 2 ]
1420 [ ]
1421 (%o2) [ 0 - 74 - 56 - 22 ]
1422 [ ]
1423 [ 0 0 626 - 74 aa 238 - 74 bb ]
1424 @end example
1426 @end deffn
1428 @deffn {Función} uniteigenvectors (@var{M})
1429 @deffnx {Función} ueivects (@var{M})
1430 Calcula los vectores propios unitarios de la matriz @var{M}. El valor que devuelve es una lista de listas, la primera de las cuales es la salida de la función @code{eigenvalues} y el resto de sublistas son los vectores propios unitarios de la matriz correspondiente a esos valores propios, respectivamente.
1432 Las variables citadas en la descripción de la función @code{eigenvectors} tienen los mismos efectos en @code{uniteigenvectors}.
1434 Si @code{knowneigvects} vale @code{true}, el paquete @code{eigen} da por supuesto que el usuario conoce los vectores propios de la matriz y que están guardados en la variable global @code{listeigvects}, en tal caso el contenido de @code{listeigvects} debe ser una lista de estructura similar a la que devuelve la función @code{eigenvectors}.
1436 @c FOLLOWING PARAGRAPH IS IN NEED OF SERIOUS CLARIFICATION
1437 Si @code{knowneigvects} vale @code{true} y la lista de vectores propios está en la variable @code{listeigvects}, el valor de la variable @code{nondiagonalizable} puede que no sea el correcto. Si tal es el caso, debe asignarsele el valor correcto. @c FALTA TERMINAR ESTE PARRAFO
1439 Para utilizar esta fucnión es necesario cargarla haciendo @code{load ("eigen")}.
1441 El nombre @code{ueivects} es sinónimo de @code{uniteigenvectors}.
1443 @end deffn
1445 @deffn {Función} unitvector (@var{x})
1446 @deffnx {Función} uvect (@var{x})
1447 Devuelve @math{@var{x}/norm(@var{x})}, esto es, el vector unitario de igual dirección y sentido que @var{x}.
1449 @code{load ("eigen")} loads this function.
1451 Para utilizar esta fucnión es necesario cargarla haciendo @code{load ("eigen")}.
1453 El nombre @code{uvect} es sinónimo de @code{unitvector}.
1455 @end deffn
1460 @deffn {Función} vectorpotential (@var{givencurl})
1461 Devuelve el vector potencial de un vector rotacional en el sistema
1462 de coordenadas actual.
1463 @code{potentialzeroloc} tiene un rol similar al de @code{potential},
1464 pero el orden del miembro izquierdo de las ecuaciones debe ser una
1465 permutación cíclica de las coordenadas.
1467 @end deffn
1472 @c NEEDS A LOT OF WORK: MAKE SURE THAT ALL VECTOR SIMPLIFICATION FLAGS HAVE A DESCRIPTION HERE
1473 @deffn {Función} vectorsimp (@var{expr})
1474 Realiza simplificaciones y expansiones de acuerdo con los valores de las siguientes variables globales:
1476 @code{expandall}, @code{expanddot}, @code{expanddotplus}, @code{expandcross}, @code{expandcrossplus},
1477 @code{expandcrosscross}, @code{expandgrad}, @code{expandgradplus}, @code{expandgradprod},
1478 @code{expanddiv}, @code{expanddivplus}, @code{expanddivprod}, @code{expandcurl}, @code{expandcurlplus},
1479 @code{expandcurlcurl}, @code{expandlaplacian}, @code{expandlaplacianplus} y @code{expandlaplacianprod}.
1481 Todas estas variables tienen por defecto el valor @code{false}. El sufijo @code{plus} se refiere al uso de la suma o la distributividad. El sufijo @code{prod} se refiere a la expansión de operadores que realizan cualquier tipo de producto.
1483 @table @code
1484 @item expandcrosscross
1485 Simplifica @math{p ~ (q ~ r)} en @math{(p . r)*q - (p . q)*r}.
1486 @item expandcurlcurl
1487 Simplifica @math{curl curl p} en @math{grad div p + div grad p}.
1488 @item expandlaplaciantodivgrad
1489 Simplifica @math{laplacian p} en @math{div grad p}.
1490 @item expandcross
1491 Activa @code{expandcrossplus} y @code{expandcrosscross}.
1492 @item expandplus
1493 Activa @code{expanddotplus}, @code{expandcrossplus}, @code{expandgradplus},
1494 @code{expanddivplus}, @code{expandcurlplus} y @code{expandlaplacianplus}.
1495 @item expandprod
1496 Activa @code{expandgradprod}, @code{expanddivprod} y @code{expandlaplacianprod}.
1497 @end table
1499 @c EXPLAIN THE IMPORT OF THIS STATEMENT
1500 Estas variables están declaradas como @code{evflag}.
1502 @c SEEMS SOME TEXT HAS GONE MISSING HERE; COMMENT OUT FRAGMENT PENDING
1503 @c RECOVERY AND/OR RECONSTRUCTION OF THIS PARAGRAPH
1504 @c For orthogonal curvilinear coordinates, the global variables
1505 @c COORDINATES[[X,Y,Z]], DIMENSION[3], SF[[1,1,1]], and SFPROD[1] are set
1506 @c by the function invocation
1508 @end deffn
1511 @c AQUI FALTA LA DEFINICION DE LA VARIABLE vect_cross
1514 @deffn {Función} zeromatrix (@var{m}, @var{n})
1515 Devuelve una matriz rectangular @var{m} por @var{n} con todos sus elementos iguales a cero.
1517 @end deffn
1519 @defvr {Símbolo especial} [
1520 @defvrx {Símbolo especial} [
1521 @ifinfo
1522 @fnindex Delimitadores de listas
1523 @fnindex Operador de subíndice
1524 @end ifinfo
1525 Los símbolos @code{[} y @code{]} marcan el comienzo y final, respectivamente, de una lista.
1527 Los símbolos @code{[} y @code{]} también se utilizan para indicar los subíndices de los elementos de una lista, arreglo o función arreglo.
1529 Ejemplos:
1531 @example
1532 (%i1) x: [a, b, c];
1533 (%o1) [a, b, c]
1534 (%i2) x[3];
1535 (%o2) c
1536 (%i3) array (y, fixnum, 3);
1537 (%o3) y
1538 (%i4) y[2]: %pi;
1539 (%o4) %pi
1540 (%i5) y[2];
1541 (%o5) %pi
1542 (%i6) z['foo]: 'bar;
1543 (%o6) bar
1544 (%i7) z['foo];
1545 (%o7) bar
1546 (%i8) g[k] := 1/(k^2+1);
1547 1
1548 (%o8) g := ------
1549 k 2
1550 k + 1
1551 (%i9) g[10];
1552 1
1553 (%o9) ---
1554 101
1555 @end example
1557 @end defvr