| blob | 69b469b62f965a11367d7a396b3579248d2b8c10 |
1 @c /Matrices.texi/1.28/Fri Mar 2 00:44:39 2007/-ko/
2 @menu
3 * Introdução a Matrizes e Álgebra Linear::
4 * Definições para Matrizes e Álgebra Linear::
5 @end menu
7 @node Introdução a Matrizes e Álgebra Linear, Definições para Matrizes e Álgebra Linear, Matrizes e Álgebra Linear, Matrizes e Álgebra Linear
8 @section Introdução a Matrizes e Álgebra Linear
10 @menu
11 * Ponto::
12 * Vetores::
13 * auto::
14 @end menu
16 @node Ponto, Vetores, Introdução a Matrizes e Álgebra Linear, Introdução a Matrizes e Álgebra Linear
17 @subsection Ponto
18 O operador @code{.} representa multiplicação não comutativa e produto escalar.
19 Quando os operandos são matrizes 1-coluna ou 1-linha @code{a} e @code{b},
20 a expresão @code{a.b} é equivalente a @code{sum (a[i]*b[i], i, 1, length(a))}.
21 Se @code{a} e @code{b} não são complexos, isso é o produto escalar,
22 também chamado produto interno ou produto do ponto, de @code{a} e @code{b}.
23 O produto escalar é definido como @code{conjugate(a).b} quando @code{a} e @code{b} são complexos;
24 @code{innerproduct} no pacote @code{eigen} fornece o produto escalar complexo.
26 Quando os operandos são matrizes mais gerais,
27 o produto é a matriz produto @code{a} e @code{b}.
28 O número de linhas de @code{b} deve ser igual ao número de colunas de @code{a},
29 e o resultado tem número de linhas igual ao número de linhas de @code{a}
30 e número de colunas igual ao número de colunas de @code{b}.
32 Para distinguir @code{.} como um operador aritmético do
33 ponto decimal em um número em ponto flutuante,
34 pode ser necessário deixar espaços em cada lado.
35 Por exemplo, @code{5.e3} é @code{5000.0} mas @code{5 . e3} é @code{5} vezes @code{e3}.
37 Existem muitos sinalizadores que governam a simplificação de
38 expresões envolvendo @code{.}, a saber
39 @code{dot}, @code{dot0nscsimp}, @code{dot0simp}, @code{dot1simp}, @code{dotassoc},
40 @code{dotconstrules}, @code{dotdistrib}, @code{dotexptsimp}, @code{dotident},
41 e @code{dotscrules}.
43 @node Vetores, auto, Ponto, Introdução a Matrizes e Álgebra Linear
44 @subsection Vetores
45 @code{vect} é um pacote de funções para análise vectorial.
46 @code{load ("vect")} chama esse pacote, e @code{demo ("vect")} permite visualizar uma demonstração.
47 @c find maxima -name \*orth\* YIELDS NOTHING; ARE THESE FUNCTIONS IN ANOTHER FILE NOW ??
48 @c and SHARE;VECT ORTH contains definitions of various orthogonal curvilinear coordinate systems.
50 O pacote de análise vectorial pode combinar e simplificar expresões
51 simbólicas incluindo produtos dos pontos e productos dos x, juntamente com
52 o gradiente, divergencia, torção, e operadores Laplacianos. A
53 distribuição desses operadores sobre adições ou produtos é governada
54 por muitos sinalizadores, como são várias outras expansões, incluindo expansão
55 dentro de componentes em qualquer sistema de coordenadas ortogonais.
56 Existem também funções para derivar o escalar ou vector potencial
57 de um campo.
59 O pacote @code{vect} contém essas funções:
60 @code{vectorsimp}, @code{scalefactors},
61 @code{express}, @code{potential}, e @code{vectorpotential}.
62 @c REVIEW vect.usg TO ENSURE THAT TEXINFO HAS WHATEVER IS THERE
63 @c PRINTFILE(VECT,USAGE,SHARE); for details.
65 Atenção: o pacote @code{vect} declara o operador ponto @code{.}
66 como sendo um operador comutativo.
68 @node auto, , Vetores, Introdução a Matrizes e Álgebra Linear
69 @subsection auto
71 O pacote @code{eigen} contém muitas funções devotadas para a
72 computação simbólica de autovalores e autovectores.
73 Maxima chama o pacote automaticamente se uma das funções
74 @code{eigenvalues} ou @code{eigenvectors} é invocada.
75 O pacote pode ser chamado explicitamente com @code{load ("eigen")}.
77 @code{demo ("eigen")} mostra uma demonstração das compatibilidades
78 desse pacote.
79 @code{batch ("eigen")} executa a mesma demonstração,
80 mas sem lembretes de utilizador entre sucessivas computações.
82 As funções no pacote @code{eigen} são
83 @code{innerproduct}, @code{unitvector}, @code{columnvector},
84 @code{gramschmidt}, @code{eigenvalues}, @code{eigenvectors}, @code{uniteigenvectors},
85 e @code{similaritytransform}.
87 @c end concepts Matrizes e Álgebra Linear
88 @node Definições para Matrizes e Álgebra Linear, , Introdução a Matrizes e Álgebra Linear, Matrizes e Álgebra Linear
89 @section Definições para Matrizes e Álgebra Linear
91 @deffn {Função} addcol (@var{M}, @var{list_1}, ..., @var{list_n})
92 Anexa a(s) coluna(s) dadas por uma
93 ou mais listas (ou matrizes) sobre a matriz @var{M}.
95 @end deffn
97 @deffn {Função} addrow (@var{M}, @var{list_1}, ..., @var{list_n})
98 Anexa a(s) linha(s) dadas por uma ou
99 mais listas (ou matrizes) sobre a matriz @var{M}.
101 @end deffn
103 @deffn {Função} adjoint (@var{M})
104 Retorna a matriz adjunta da matriz @var{M}.
105 A matriz adjunta é a transposta da matriz dos cofactores de @var{M}.
107 @end deffn
109 @deffn {Função} augcoefmatrix ([@var{eqn_1}, ..., @var{eqn_m}], [@var{x_1}, ..., @var{x_n}])
110 Retorna a matriz dos coeficientes
111 aumentada para as variáveis @var{x_1}, ..., @var{x_n} do sistema de equações lineares
112 @var{eqn_1}, ..., @var{eqn_m}. Essa é a matriz dos coeficientes com uma coluna anexada para
113 os termos independentes em cada equação (i.e., esses termos não dependem de
114 @var{x_1}, ..., @var{x_n}).
116 @example
117 (%i1) m: [2*x - (a - 1)*y = 5*b, c + b*y + a*x = 0]$
118 (%i2) augcoefmatrix (m, [x, y]);
119 [ 2 1 - a - 5 b ]
120 (%o2) [ ]
121 [ a b c ]
122 @end example
124 @end deffn
126 @deffn {Função} charpoly (@var{M}, @var{x})
127 Retorna um polinómio característico para a matriz @var{M}
128 em relação à variável @var{x}. Que é,
129 @code{determinant (@var{M} - diagmatrix (length (@var{M}), @var{x}))}.
131 @example
132 (%i1) a: matrix ([3, 1], [2, 4]);
133 [ 3 1 ]
134 (%o1) [ ]
135 [ 2 4 ]
136 (%i2) expand (charpoly (a, lambda));
137 2
138 (%o2) lambda - 7 lambda + 10
139 (%i3) (programmode: true, solve (%));
140 (%o3) [lambda = 5, lambda = 2]
141 (%i4) matrix ([x1], [x2]);
142 [ x1 ]
143 (%o4) [ ]
144 [ x2 ]
145 (%i5) ev (a . % - lambda*%, %th(2)[1]);
146 [ x2 - 2 x1 ]
147 (%o5) [ ]
148 [ 2 x1 - x2 ]
149 (%i6) %[1, 1] = 0;
150 (%o6) x2 - 2 x1 = 0
151 (%i7) x2^2 + x1^2 = 1;
152 2 2
153 (%o7) x2 + x1 = 1
154 (%i8) solve ([%th(2), %], [x1, x2]);
155 1 2
156 (%o8) [[x1 = - -------, x2 = - -------],
157 sqrt(5) sqrt(5)
159 1 2
160 [x1 = -------, x2 = -------]]
161 sqrt(5) sqrt(5)
162 @end example
164 @end deffn
166 @deffn {Função} coefmatrix ([@var{eqn_1}, ..., @var{eqn_m}], [@var{x_1}, ..., @var{x_n}])
167 Retorna a matriz dos coeficientes para as
168 variáveis @var{x_1}, ..., @var{x_n} do sistema de equações lineares
169 @var{eqn_1}, ..., @var{eqn_m}.
171 @example
172 (%i1) coefmatrix([2*x-(a-1)*y+5*b = 0, b*y+a*x = 3], [x,y]);
173 [ 2 1 - a ]
174 (%o1) [ ]
175 [ a b ]
176 @end example
178 @end deffn
180 @deffn {Função} col (@var{M}, @var{i})
181 Reorna a @var{i}'ésima coluna da matriz @var{M}.
182 O valor de retorno é uma matriz.
183 @c EXAMPLE HERE
185 @end deffn
187 @deffn {Função} columnvector (@var{L})
188 @deffnx {Função} covect (@var{L})
189 Retorna uma matriz de uma coluna e @code{length (@var{L})} linhas,
190 contendo os elementos da lista @var{L}.
192 @code{covect} é um sin@^onimo para @code{columnvector}.
194 @code{load ("eigen")} chama essa função.
196 @c FOLLOWING COMMENT PRESERVED. WHAT DOES THIS MEAN ??
197 Isso é útil se quiser usar partes das saídas das
198 funções nesse pacote em cálculos matriciais.
200 Exemplo:
202 @c HMM, SPURIOUS "redefining the Macsyma function".
203 @c LEAVE IT HERE SINCE THAT'S WHAT A USER ACTUALLY SEES.
204 @example
205 (%i1) load ("eigen")$
206 Warning - you are redefining the Macsyma function autovalores
207 Warning - you are redefining the Macsyma function autovectores
208 (%i2) columnvector ([aa, bb, cc, dd]);
209 [ aa ]
210 [ ]
211 [ bb ]
212 (%o2) [ ]
213 [ cc ]
214 [ ]
215 [ dd ]
216 @end example
218 @end deffn
220 @deffn {Função} conjugate (@var{x})
221 Retorna o conjugado complexo de @var{x}.
223 @c ===beg===
224 @c declare ([aa, bb], real, cc, complex, ii, imaginary);
225 @c conjugate (aa + bb*%i);
226 @c conjugate (cc);
227 @c conjugate (ii);
228 @c conjugate (xx + yy);
229 @c ===end===
230 @example
231 (%i1) declare ([aa, bb], real, cc, complex, ii, imaginary);
233 (%o1) done
234 (%i2) conjugate (aa + bb*%i);
236 (%o2) aa - %i bb
237 (%i3) conjugate (cc);
239 (%o3) conjugate(cc)
240 (%i4) conjugate (ii);
242 (%o4) - ii
243 (%i5) conjugate (xx + yy);
245 (%o5) conjugate(yy) + conjugate(xx)
246 @end example
248 @end deffn
250 @deffn {Função} copymatrix (@var{M})
251 Retorna uma cópia da matriz @var{M}. Esse é o único
252 para fazer uma copia separada copiando @var{M} elemento a elemento.
254 Note que uma atribuição de uma matriz para outra, como em @code{m2: m1},
255 não copia @code{m1}.
256 Uma atribuição @code{m2 [i,j]: x} ou @code{setelmx (x, i, j, m2} também modifica @code{m1 [i,j]}.
257 criando uma cópia com @code{copymatrix} e então usando atribução cria uma separada e modificada cópia.
259 @c NEED EXAMPLE HERE
260 @end deffn
262 @deffn {Função} determinant (@var{M})
263 Calcula o determinante de @var{M} por um método similar à
264 eliminação de Gauss.
266 @c JUST HOW DOES ratmx AFFECT THE RESULT ??
267 A forma do resultado depende da escolha
268 do comutador @code{ratmx}.
270 @c IS A SPARSE DETERMINANT SOMETHING OTHER THAN THE DETERMINANT OF A SPARSE MATRIX ??
271 Existe uma rotina especial para calcular
272 determinantes esparsos que é chamada quando os comutadores
273 @code{ratmx} e @code{sparse} são ambos @code{true}.
275 @c EXAMPLES NEEDED HERE
276 @end deffn
278 @defvr {Variável} detout
279 Valor por omissão: @code{false}
281 Quando @code{detout} é @code{true}, o determinante de uma
282 matriz cuja inversa é calculada é factorado fora da inversa.
284 Para esse comutador ter efeito @code{doallmxops} e @code{doscmxops} deveram ambos serem
285 @code{false} (veja suas transcrições). Alternativamente esses comutadores podem ser
286 dados para @code{ev} o que faz com que os outros dois sejam escolhidos correctamente.
288 Exemplo:
290 @example
291 (%i1) m: matrix ([a, b], [c, d]);
292 [ a b ]
293 (%o1) [ ]
294 [ c d ]
295 (%i2) detout: true$
296 (%i3) doallmxops: false$
297 (%i4) doscmxops: false$
298 (%i5) invert (m);
299 [ d - b ]
300 [ ]
301 [ - c a ]
302 (%o5) ------------
303 a d - b c
304 @end example
305 @c THERE'S MORE TO THIS STORY: detout: false$ invert (m); RETURNS THE SAME THING.
306 @c IT APPEARS THAT doallmxops IS CRUCIAL HERE.
308 @end defvr
310 @deffn {Função} diagmatrix (@var{n}, @var{x})
311 Retorna uma matriz diagonal de tamanho @var{n} por @var{n} com os
312 elementos da diagonal todos iguais a @var{x}.
313 @code{diagmatrix (@var{n}, 1)} retorna uma matriz identidade (o mesmo que @code{ident (@var{n})}).
315 @var{n} deve avaliar para um inteiro, de outra forma @code{diagmatrix} reclama com uma mensagem de erro.
317 @var{x} pode ser qualquer tipo de expresão, incluindo outra matriz.
318 Se @var{x} é uma matriz, isso não é copiado; todos os elementos da diagonal referem-se à mesma instância, @var{x}.
320 @c NEED EXAMPLE HERE
321 @end deffn
323 @defvr {Variável} doallmxops
324 Valor por omissão: @code{true}
326 Quando @code{doallmxops} é @code{true},
327 @c UMM, WHAT DOES THIS MEAN EXACTLY ??
328 todas as operações relacionadas a matrizes são realizadas.
329 Quando isso é @code{false} então a escolha de
330 comutadores individuais @code{dot} governam quais operações são executadas.
332 @c NEED EXAMPLES HERE
333 @end defvr
335 @defvr {Variável} domxexpt
336 Valor por omissão: @code{true}
338 Quando @code{domxexpt} é @code{true},
339 uma matriz exponencial, @code{exp (@var{M})} onde @var{M} é a matriz,
340 é interpretada como uma matriz com elementos @code{[i,j} iguais a @code{exp (m[i,j])}.
341 de outra forma @code{exp (@var{M})} avalia para @code{exp (@var{ev(M)}}.
343 @code{domxexpt}
344 afecta todas as expresões da forma @code{@var{base}^@var{expoente}} onde @var{base} é uma
345 expresão assumida escalar ou constante, e @var{expoente} é uma lista ou
346 matriz.
348 Exemplo:
350 @example
351 (%i1) m: matrix ([1, %i], [a+b, %pi]);
352 [ 1 %i ]
353 (%o1) [ ]
354 [ b + a %pi ]
355 (%i2) domxexpt: false$
356 (%i3) (1 - c)^m;
357 [ 1 %i ]
358 [ ]
359 [ b + a %pi ]
360 (%o3) (1 - c)
361 (%i4) domxexpt: true$
362 (%i5) (1 - c)^m;
363 [ %i ]
364 [ 1 - c (1 - c) ]
365 (%o5) [ ]
366 [ b + a %pi ]
367 [ (1 - c) (1 - c) ]
368 @end example
370 @end defvr
372 @defvr {Variável de opção} domxmxops
373 Valor por omissão: @code{true}
375 Quando @code{domxmxops} é @code{true}, todas as operações matriz-matriz ou
376 matriz-lista são realizadas (mas não operações
377 escalar-matriz); se esse comutador é @code{false} tais operações não são.
378 @c IS THIS AN EVALUATION OR A SIMPLIFICATION FLAG ??
380 @c NEED EXAMPLE HERE
381 @end defvr
383 @defvr {Variável de opção} domxnctimes
384 Valor por omissão: @code{false}
386 Quando @code{domxnctimes} é @code{true}, produtos não comutativos de
387 matrizes são realizados.
388 @c IS THIS AN EVALUATION OR A SIMPLIFICATION FLAG ??
390 @c NEED EXAMPLE HERE
391 @end defvr
393 @defvr {Variável de opção} dontfactor
394 Valor por omissão: @code{[]}
396 @code{dontfactor} pode ser escolhido para uma lista de variáveis em relação
397 a qual factoração não é para ocorrer. (A lista é inicialmente vazia.)
398 Factoração também não pegará lugares com relação a quaisquer variáveis que
399 são menos importantes, conforme a hierarquía de variável assumida para a forma expresão racional canónica (CRE),
400 que essas na lista @code{dontfactor}.
402 @end defvr
404 @defvr {Variável de opção} doscmxops
405 Valor por omissão: @code{false}
407 Quando @code{doscmxops} é @code{true}, operações escalar-matriz são
408 realizadas.
409 @c IS THIS AN EVALUATION OR A SIMPLIFICATION FLAG ??
411 @c NEED EXAMPLE HERE
412 @end defvr
414 @defvr {Variável de opção} doscmxplus
415 Valor por omissão: @code{false}
417 Quando @code{doscmxplus} é @code{true}, operações escalar-matriz retornam
418 uma matriz resultado. Esse comutador não é subsomado sob @code{doallmxops}.
419 @c IS THIS AN EVALUATION OR A SIMPLIFICATION FLAG ??
421 @c NEED EXAMPLE HERE
422 @end defvr
424 @defvr {Variável de opção} dot0nscsimp
425 Valor por omissão: @code{true}
427 @c WHAT DOES THIS MEAN EXACTLY ??
428 Quando @code{dot0nscsimp} é @code{true}, um produto não comutativo de zero
429 e um termo não escalar é simplificado para um produto comutativo.
431 @c NEED EXAMPLE HERE
432 @end defvr
434 @defvr {Variável de opção} dot0simp
435 Valor por omissão: @code{true}
437 @c WHAT DOES THIS MEAN EXACTLY ??
438 Quando @code{dot0simp} é @code{true},
439 um produto não comutativo de zero e
440 um termo escalar é simplificado para um produto não comutativo.
442 @c NEED EXAMPLE HERE
443 @end defvr
445 @defvr {Variável de opção} dot1simp
446 Valor por omissão: @code{true}
448 @c WHAT DOES THIS MEAN EXACTLY ??
449 Quando @code{dot1simp} é @code{true},
450 um produto não comutativo de um e
451 outro termo é simplificado para um produto comutativo.
453 @c NEED EXAMPLE HERE
454 @end defvr
456 @defvr {Variável de opção} dotassoc
457 Valor por omissão: @code{true}
459 Quando @code{dotassoc} é @code{true}, uma expresão @code{(A.B).C} simplifica para
460 @code{A.(B.C)}.
461 @c "." MEANS NONCOMMUTATIVE MULTIPLICATION RIGHT ??
463 @c NEED EXAMPLE HERE
464 @end defvr
466 @defvr {Variável de opção} dotconstrules
467 Valor por omissão: @code{true}
469 Quando @code{dotconstrules} é @code{true}, um produto não comutativo de uma
470 constante e outro termo é simplificado para um produto comutativo.
471 @c TERMINOLOGY: (1) SWITCH/FLAG/SOME OTHER TERM ?? (2) ASSIGN/SET/TURN ON/SOME OTHER TERM ??
472 Ativando esse sinalizador efectivamente activamos @code{dot0simp}, @code{dot0nscsimp}, e
473 @code{dot1simp} também.
475 @c NEED EXAMPLE HERE
476 @end defvr
478 @defvr {Variável de opção} dotdistrib
479 Valor por omissão: @code{false}
481 Quando @code{dotdistrib} é @code{true}, uma expresão @code{A.(B + C)} simplifica para @code{A.B + A.C}.
483 @c NEED EXAMPLE HERE
484 @end defvr
486 @defvr {Variável de opção} dotexptsimp
487 Valor por omissão: @code{true}
489 Quando @code{dotexptsimp} é @code{true}, uma expresão @code{A.A} simplifica para @code{A^^2}.
491 @c NEED EXAMPLE HERE
492 @end defvr
494 @defvr {Variável de opção} dotident
495 Valor por omissão: 1
497 @code{dotident} é o valor retornado por @code{X^^0}.
498 @c "RETURNED" ?? IS THIS A SIMPLIFICATION OR AN EVALUATION ??
500 @c NEED EXAMPLE HERE
501 @end defvr
503 @defvr {Variável de opção} dotscrules
504 Valor por omissão: @code{false}
506 Quando @code{dotscrules} é @code{true}, uma expresão @code{A.SC} ou @code{SC.A} simplifica
507 para @code{SC*A} e @code{A.(SC*B)} simplifica para @code{SC*(A.B)}.
508 @c HMM, DOES "SC" MEAN "SCALAR" HERE ?? CLARIFY
510 @c NEED EXAMPLE HERE
511 @end defvr
513 @deffn {Função} echelon (@var{M})
514 Retorna a forma escalonada da matriz @var{M},
515 como produzido através da eliminação de Gauss.
516 A forma escalonada é calculada de @var{M}
517 por operações elementares de linha tais que o primeiro
518 elemento não zero em cada linha na matriz resultante seja o número um e os
519 elementos da coluna abaixo do primeiro número um em cada linha sejam todos zero.
521 @code{triangularize} também realiza eliminação de Gaussian,
522 mas não normaliza o elemento líder não nulo em cada linha.
524 @code{lu_factor} e @code{cholesky} são outras funções que retornam matrizes triangularizadas.
526 @c ===beg===
527 @c M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
528 @c echelon (M);
529 @c ===end===
530 @example
531 (%i1) M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
532 [ 3 7 aa bb ]
533 [ ]
534 (%o1) [ - 1 8 5 2 ]
535 [ ]
536 [ 9 2 11 4 ]
537 (%i2) echelon (M);
538 [ 1 - 8 - 5 - 2 ]
539 [ ]
540 [ 28 11 ]
541 [ 0 1 -- -- ]
542 (%o2) [ 37 37 ]
543 [ ]
544 [ 37 bb - 119 ]
545 [ 0 0 1 ----------- ]
546 [ 37 aa - 313 ]
547 @end example
549 @end deffn
551 @deffn {Função} eigenvalues (@var{M})
552 @deffnx {Função} eivals (@var{M})
553 @c eigen.mac IS AUTOLOADED IF eigenvalues OR eigenvectors IS REFERENCED; EXTEND THAT TO ALL FUNCTIONS ??
554 @c EACH FUNCTION INTENDED FOR EXTERNAL USE SHOULD HAVE ITS OWN DOCUMENTATION ITEM
555 Retorna uma lista de duas listas contendo os autovalores da matriz @var{M}.
556 A primeira sublista do valor de retorno é a lista de autovalores da
557 matriz, e a segunda sublista é a lista de
558 multiplicidade dos autovalores na ordem correspondente.
560 @code{eivals} é um sin@^onimo de @code{eigenvalues}.
562 @code{eigenvalues} chama a função @code{solve} para achar as raízes do
563 polinómio característico da matriz.
564 Algumas vezes @code{solve} pode não estar habilitado a achar as raízes do polinómio;
565 nesse caso algumas outras funções nesse
566 pacote (except @code{innerproduct}, @code{unitvector}, @code{columnvector} e
567 @code{gramschmidt}) não irão trabalhar.
568 @c WHICH ONES ARE THE FUNCTIONS WHICH DON'T WORK ??
569 @c ACTUALLY IT'S MORE IMPORTANT TO LIST THE ONES WHICH DON'T WORK HERE
570 @c WHAT DOES "will not work" MEAN, ANYWAY ??
572 Em alguns casos os autovalores achados por @code{solve} podem ser expresões complicadas.
573 (Isso pode acontecer quando @code{solve} retorna uma expresão real não trivial
574 para um autovalor que é sabidamente real.)
575 Isso pode ser possível para simplificar os autovalores usando algumas outras funções.
576 @c WHAT ARE THOSE OTHER FUNCTIONS ??
578 O pacote @code{eigen.mac} é chamado automaticamente quando
579 @code{eigenvalues} ou @code{eigenvectors} é referenciado.
580 Se @code{eigen.mac} não tiver sido ainda chamado,
581 @code{load ("eigen")} chama-o.
582 Após ser chamado, todas as funções e variáveis no pacote estarão disponíveis.
583 @c REFER TO OVERVIEW OF PACKAGE (INCLUDING LIST OF FUNCTIONS) HERE
585 @c NEED EXAMPLES HERE
586 @end deffn
588 @deffn {Função} eigenvectors (@var{M})
589 @deffnx {Função} eivects (@var{M})
590 pegam uma matriz @var{M} como seu argumento e retorna uma lista
591 de listas cuja primeira sublista é a saída de @code{eigenvalues}
592 e as outras sublistas são os autovectores da
593 matriz correspondente para esses autovalores respectivamente.
595 @code{eivects} é um sin@^onimo para @code{eigenvectors}.
597 O pacote @code{eigen.mac} é chamado automaticamente quando
598 @code{eigenvalues} ou @code{eigenvectors} é referenciado.
599 Se @code{eigen.mac} não tiver sido ainda chamado,
600 @code{load ("eigen")} chama-o.
601 Após ser chamado, todas as funções e variáveis no pacote estarão disponíveis.
603 Os sinalizadores que afectam essa função são:
605 @code{nondiagonalizable} é escolhido para @code{true} ou @code{false} dependendo de
606 se a matriz é não diagonalizável ou diagonalizável após o
607 retorno de @code{eigenvectors}.
609 @code{hermitianmatrix} quando @code{true}, faz com que os autovectores
610 degenerados da matriz Hermitiana sejam ortogonalizados usando o
611 algoritmo de Gram-Schmidt.
613 @code{knowneigvals} quando @code{true} faz com que o pacote @code{eigen} assumir que os
614 autovalores da matriz são conhecidos para o utilizador e armazenados sob o
615 nome global @code{listeigvals}. @code{listeigvals} poderá ser escolhido para uma lista similar
616 à saída de @code{eigenvalues}.
618 A função @code{algsys} é usada aqui para resolver em relação aos autovectores. Algumas vezes se os
619 autovalores estão ausêntes, @code{algsys} pode não estar habilitado a achar uma solução.
620 Em alguns casos, isso pode ser possível para simplificar os autovalores por
621 primeiro achando e então usando o comando @code{eigenvalues} e então usando outras funções
622 para reduzir os autovalores a alguma coisa mais simples.
623 Continuando a simplificação, @code{eigenvectors} pode ser chamada novamente
624 com o sinalizador @code{knowneigvals} escolhido para @code{true}.
626 @end deffn
628 @deffn {Função} ematrix (@var{m}, @var{n}, @var{x}, @var{i}, @var{j})
629 Retorna uma matriz @var{m} por @var{n}, todos os elementos da qual
630 são zero excepto para o elemento @code{[@var{i}, @var{j}]} que é @var{x}.
631 @c WOW, THAT SEEMS PRETTY SPECIALIZED ...
633 @end deffn
635 @deffn {Função} entermatrix (@var{m}, @var{n})
636 Retorna uma matriz @var{m} por @var{n}, lendo os elementos interativamente.
638 Se @var{n} é igual a @var{m},
639 Maxima pergunta pelo tipo de matriz (diagonal, simétrica, antisimétrica, ou genérica)
640 e por cada elemento.
641 Cada resposta é terminada por um ponto e vírgula @code{;} ou sinal de dólar @code{$}.
643 Se @var{n} não é igual a @var{m},
644 Maxima pergunta por cada elemento.
646 Os elementos podem ser quaisquer expressões, que são avaliadas.
647 @code{entermatrix} avalia seus argumentos.
649 @example
650 (%i1) n: 3$
651 (%i2) m: entermatrix (n, n)$
653 Is the matriz 1. Diagonal 2. Symmetric 3. Antisymmetric 4. General
654 Answer 1, 2, 3 or 4 :
655 1$
656 Row 1 Column 1:
657 (a+b)^n$
658 Row 2 Column 2:
659 (a+b)^(n+1)$
660 Row 3 Column 3:
661 (a+b)^(n+2)$
663 Matriz entered.
664 (%i3) m;
665 [ 3 ]
666 [ (b + a) 0 0 ]
667 [ ]
668 (%o3) [ 4 ]
669 [ 0 (b + a) 0 ]
670 [ ]
671 [ 5 ]
672 [ 0 0 (b + a) ]
673 @end example
675 @end deffn
677 @deffn {Função} genmatrix (@var{a}, @var{i_2}, @var{j_2}, @var{i_1}, @var{j_1})
678 @deffnx {Função} genmatrix (@var{a}, @var{i_2}, @var{j_2}, @var{i_1})
679 @deffnx {Função} genmatrix (@var{a}, @var{i_2}, @var{j_2})
680 Retorna uma matriz gerada de @var{a},
681 pegando o elemento @code{@var{a}[@var{i_1},@var{j_1}]}
682 como o elemento do canto superior esquerdo e @code{@var{a}[@var{i_2},@var{j_2}]}
683 como o elemento do canto inferior directo da matriz.
684 Aqui @var{a} é um array declarado (criado através de @code{array} mas não por meio de @code{make_array})
685 ou um array não declarado,
686 ou uma função array,
687 ou uma expressão lambda de dois argumentos.
688 (Uma funçãO array é criado como outras funções com @code{:=} ou @code{define},
689 mas os argumentos são colocados entre colchêtes em lugar de parêntesis.)
691 Se @var{j_1} é omitido, isso é assumido ser igual a @var{i_1}.
692 Se ambos @var{j_1} e @var{i_1} são omitidos, ambos são assumidos iguais a 1.
694 Se um elemento seleccionado @code{i,j} de um array for indefinido,
695 a matriz conterá um elemento simbólico @code{@var{a}[i,j]}.
697 Exemplos:
699 @c ===beg===
700 @c h [i, j] := 1 / (i + j - 1);
701 @c genmatrix (h, 3, 3);
702 @c array (a, fixnum, 2, 2);
703 @c a [1, 1] : %e;
704 @c a [2, 2] : %pi;
705 @c genmatrix (a, 2, 2);
706 @c genmatrix (lambda ([i, j], j - i), 3, 3);
707 @c genmatrix (B, 2, 2);
708 @c ===end===
709 @example
710 (%i1) h [i, j] := 1 / (i + j - 1);
711 1
712 (%o1) h := ---------
713 i, j i + j - 1
714 (%i2) genmatrix (h, 3, 3);
715 [ 1 1 ]
716 [ 1 - - ]
717 [ 2 3 ]
718 [ ]
719 [ 1 1 1 ]
720 (%o2) [ - - - ]
721 [ 2 3 4 ]
722 [ ]
723 [ 1 1 1 ]
724 [ - - - ]
725 [ 3 4 5 ]
726 (%i3) array (a, fixnum, 2, 2);
727 (%o3) a
728 (%i4) a [1, 1] : %e;
729 (%o4) %e
730 (%i5) a [2, 2] : %pi;
731 (%o5) %pi
732 (%i6) genmatrix (a, 2, 2);
733 [ %e 0 ]
734 (%o6) [ ]
735 [ 0 %pi ]
736 (%i7) genmatrix (lambda ([i, j], j - i), 3, 3);
737 [ 0 1 2 ]
738 [ ]
739 (%o7) [ - 1 0 1 ]
740 [ ]
741 [ - 2 - 1 0 ]
742 (%i8) genmatrix (B, 2, 2);
743 [ B B ]
744 [ 1, 1 1, 2 ]
745 (%o8) [ ]
746 [ B B ]
747 [ 2, 1 2, 2 ]
748 @end example
750 @end deffn
752 @deffn {Função} gramschmidt (@var{x})
753 @deffnx {Função} gschmit (@var{x})
754 Realiza o algoritmo de ortonalização de Gram-Schmidt sobre @var{x},
755 seja ela uma matriz ou uma lista de listas.
756 @var{x} não é modificado por @code{gramschmidt}.
758 Se @var{x} é uma matriz, o algoritmo é aplicado para as linhas de @var{x}.
759 Se @var{x} é uma lista de listas, o algoritmo é aplicado às sublistas,
760 que devem ter igual números de elementos.
761 Nos dois casos,
762 o valor de retorno é uma lista de listas, as sublistas das listas são ortogonais
763 e gera o mesmo spaço que @var{x}.
764 Se a dimensão do conjunto gerador de @var{x} é menor que o número de linhas ou sublistas,
765 algumas sublistas do valor de retorno são zero.
767 @code{factor} é chamada a cada estágio do algoritmo para simplificar resultados intermédios.
768 Como uma consequência, o valor de retorno pode conter inteiros factorados.
770 @code{gschmit} (nota ortográfica) é um sin@^onimo para @code{gramschmidt}.
772 @code{load ("eigen")} chama essa função.
774 Exemplo:
776 @example
777 (%i1) load ("eigen")$
778 Warning - you are redefining the Macsyma function autovalores
779 Warning - you are redefining the Macsyma function autovectores
780 (%i2) x: matrix ([1, 2, 3], [9, 18, 30], [12, 48, 60]);
781 [ 1 2 3 ]
782 [ ]
783 (%o2) [ 9 18 30 ]
784 [ ]
785 [ 12 48 60 ]
786 (%i3) y: gramschmidt (x);
787 2 2 4 3
788 3 3 3 5 2 3 2 3
789 (%o3) [[1, 2, 3], [- ---, - --, ---], [- ----, ----, 0]]
790 2 7 7 2 7 5 5
791 (%i4) i: innerproduct$
792 (%i5) [i (y[1], y[2]), i (y[2], y[3]), i (y[3], y[1])];
793 (%o5) [0, 0, 0]
794 @end example
796 @end deffn
798 @deffn {Função} ident (@var{n})
799 Retorna uma matriz identidade @var{n} por @var{n}.
801 @end deffn
803 @deffn {Função} innerproduct (@var{x}, @var{y})
804 @deffnx {Função} inprod (@var{x}, @var{y})
805 Retorna o produto interno (também chamado produto escalar ou produto do ponto) de @var{x} e @var{y},
806 que são listas de igual comprimento, ou ambas matrizes 1-coluna ou 1-linha de igual comprimento.
807 O valor de retorno é @code{conjugate (x) . y},
808 onde @code{.} é o operador de multiplicação não comutativa.
810 @code{load ("eigen")} chama essa função.
812 @code{inprod} é um sin@^onimo para @code{innerproduct}.
814 @c NEED EXAMPLE HERE
815 @end deffn
817 @c THIS DESCRIPTION NEEDS WORK
818 @deffn {Função} invert (@var{M})
819 Retorna a inversa da matriz @var{M}.
820 A inversa é calculada pelo método adjunto.
822 Isso permite a um utilizador calcular a inversa de uma matriz com
823 entradas bfloat ou polinómios com coeficientes em ponto flutuante sem
824 converter para a forma CRE.
826 Cofactores são calculados pela função @code{determinant},
827 então se @code{ratmx} é @code{false} a inversa é calculada
828 sem mudar a representação dos elementos.
830 A implementação
831 corrente é ineficiente para matrizes de alta ordem.
833 Quando @code{detout} é @code{true}, o determinante é factorado fora da
834 inversa.
836 Os elementos da inversa não são automaticamente expandidos.
837 Se @var{M} tem elementos polinomiais, melhor aparência de saída pode ser
838 gerada por @code{expand (invert (m)), detout}.
839 Se isso é desejável para ela
840 divisão até pelo determinante pode ser excelente por @code{xthru (%)}
841 ou alternativamente na unha por
843 @example
844 expe (adjoint (m)) / expand (determinant (m))
845 invert (m) := adjoint (m) / determinant (m)
846 @end example
848 Veja @code{^^} (expoente não comutativo) para outro método de inverter uma matriz.
850 @c NEED EXAMPLE HERE
851 @end deffn
853 @defvr {Variável de opção} lmxchar
854 Valor por omissão: @code{[}
856 @code{lmxchar} é o caractere mostrado como o delimitador
857 esquerdo de uma matriz.
858 Veja também @code{rmxchar}.
860 Exemplo:
862 @example
863 (%i1) lmxchar: "|"$
864 (%i2) matrix ([a, b, c], [d, e, f], [g, h, i]);
865 | a b c ]
866 | ]
867 (%o2) | d e f ]
868 | ]
869 | g h i ]
870 @end example
872 @end defvr
874 @deffn {Função} matrix (@var{row_1}, ..., @var{row_n})
875 Retorna uma matriz retangular que tem as linhas @var{row_1}, ..., @var{row_n}.
876 Cada linha é uma lista de expressões.
877 Todas as linhas devem ter o mesmo comprimento.
879 As operações @code{+} (adição), @code{-} (subtração), @code{*} (multiplicação),
880 e @code{/} (divisão), são realizadas elemento por elemento
881 quando os operandos são duas matrizes, um escalar e uma matriz, ou uma matriz e um escalar.
882 A operação @code{^} (exponenciação, equivalentemente @code{**})
883 é realizada elemento por elemento
884 se os operandos são um escalar e uma matriz ou uma matriz e um escalar,
885 mas não se os operandos forem duas matrizes.
886 @c WHAT DOES THIS NEXT PHRASE MEAN EXACTLY ??
887 Todos as operações são normalmente realizadas de forma completa,
888 incluindo @code{.} (multiplicação não comutativa).
890 Multiplicação de matrizes é representada pelo operador de multiplicação não comutativa @code{.}.
891 O correspondente operador de exponenciação não comutativa é @code{^^}.
892 Para uma matriz @code{@var{A}}, @code{@var{A}.@var{A} = @var{A}^^2} e
893 @code{@var{A}^^-1} é a inversa de @var{A}, se existir.
895 Existem comutadores para controlar a simplificação de expresões
896 envolvendo operações escalar e matriz-lista.
897 São eles
898 @code{doallmxops}, @code{domxexpt}
899 @code{domxmxops}, @code{doscmxops}, e @code{doscmxplus}.
900 @c CHECK -- WE PROBABLY WANT EXHAUSTIVE LIST HERE
902 Existem opções adicionais que são relacionadas a matrizes. São elas:
903 @code{lmxchar}, @code{rmxchar}, @code{ratmx}, @code{listarith}, @code{detout},
904 @code{scalarmatrix},
905 e @code{sparse}.
906 @c CHECK -- WE PROBABLY WANT EXHAUSTIVE LIST HERE
908 Existe um número de
909 funções que pegam matrizes como argumentos ou devolvem matrizes como valor de retorno.
910 Veja @code{eigenvalues}, @code{eigenvectors},
911 @code{determinant},
912 @code{charpoly}, @code{genmatrix}, @code{addcol}, @code{addrow},
913 @code{copymatrix}, @code{transpose}, @code{echelon},
914 e @code{rank}.
915 @c CHECK -- WE PROBABLY WANT EXHAUSTIVE LIST HERE
917 Exemplos:
919 @itemize @bullet
920 @item
921 Construção de matrizes de listas.
922 @end itemize
923 @example
924 (%i1) x: matrix ([17, 3], [-8, 11]);
925 [ 17 3 ]
926 (%o1) [ ]
927 [ - 8 11 ]
928 (%i2) y: matrix ([%pi, %e], [a, b]);
929 [ %pi %e ]
930 (%o2) [ ]
931 [ a b ]
932 @end example
933 @itemize @bullet
934 @item
935 Adição, elemento por elemento.
936 @end itemize
937 @example
938 (%i3) x + y;
939 [ %pi + 17 %e + 3 ]
940 (%o3) [ ]
941 [ a - 8 b + 11 ]
942 @end example
943 @itemize @bullet
944 @item
945 Subtração, elemento por elemento.
946 @end itemize
947 @example
948 (%i4) x - y;
949 [ 17 - %pi 3 - %e ]
950 (%o4) [ ]
951 [ - a - 8 11 - b ]
952 @end example
953 @itemize @bullet
954 @item
955 Multiplicação, elemento por elemento.
956 @end itemize
957 @example
958 (%i5) x * y;
959 [ 17 %pi 3 %e ]
960 (%o5) [ ]
961 [ - 8 a 11 b ]
962 @end example
963 @itemize @bullet
964 @item
965 Divisão, elemento por elemento.
966 @end itemize
967 @example
968 (%i6) x / y;
969 [ 17 - 1 ]
970 [ --- 3 %e ]
971 [ %pi ]
972 (%o6) [ ]
973 [ 8 11 ]
974 [ - - -- ]
975 [ a b ]
976 @end example
977 @itemize @bullet
978 @item
979 Matriz para um expoente escalar, elemento por elemento.
980 @end itemize
981 @example
982 (%i7) x ^ 3;
983 [ 4913 27 ]
984 (%o7) [ ]
985 [ - 512 1331 ]
986 @end example
987 @itemize @bullet
988 @item
989 Base escalar para um expoente matriz, elemento por elemento.
990 @end itemize
991 @example
992 (%i8) exp(y);
993 [ %pi %e ]
994 [ %e %e ]
995 (%o8) [ ]
996 [ a b ]
997 [ %e %e ]
998 @end example
999 @itemize @bullet
1000 @item
1001 Base matriz para um expoente matriz. Essa não é realizada elemento por elemento.
1002 @c WHAT IS THIS ??
1003 @end itemize
1004 @example
1005 (%i9) x ^ y;
1006 [ %pi %e ]
1007 [ ]
1008 [ a b ]
1009 [ 17 3 ]
1010 (%o9) [ ]
1011 [ - 8 11 ]
1012 @end example
1013 @itemize @bullet
1014 @item
1015 Multiplicação não comutativa de matrizes.
1016 @end itemize
1017 @example
1018 (%i10) x . y;
1019 [ 3 a + 17 %pi 3 b + 17 %e ]
1020 (%o10) [ ]
1021 [ 11 a - 8 %pi 11 b - 8 %e ]
1022 (%i11) y . x;
1023 [ 17 %pi - 8 %e 3 %pi + 11 %e ]
1024 (%o11) [ ]
1025 [ 17 a - 8 b 11 b + 3 a ]
1026 @end example
1027 @itemize @bullet
1028 @item
1029 Exponenciação não comutativa de matrizes.
1030 Uma base escalar @var{b} para uma potência matriz @var{M}
1031 é realizada elemento por elemento e então @code{b^^m} é o mesmo que @code{b^m}.
1032 @end itemize
1033 @example
1034 (%i12) x ^^ 3;
1035 [ 3833 1719 ]
1036 (%o12) [ ]
1037 [ - 4584 395 ]
1038 (%i13) %e ^^ y;
1039 [ %pi %e ]
1040 [ %e %e ]
1041 (%o13) [ ]
1042 [ a b ]
1043 [ %e %e ]
1044 @end example
1045 @itemize @bullet
1046 @item
1047 A matriz elevada a um expoente -1 com exponenciação não comutativa é a matriz inversa,
1048 se existir.
1049 @end itemize
1050 @example
1051 (%i14) x ^^ -1;
1052 [ 11 3 ]
1053 [ --- - --- ]
1054 [ 211 211 ]
1055 (%o14) [ ]
1056 [ 8 17 ]
1057 [ --- --- ]
1058 [ 211 211 ]
1059 (%i15) x . (x ^^ -1);
1060 [ 1 0 ]
1061 (%o15) [ ]
1062 [ 0 1 ]
1063 @end example
1065 @end deffn
1067 @deffn {Função} matrixmap (@var{f}, @var{M})
1068 Retorna uma matriz com elemento @code{i,j} igual a @code{@var{f}(@var{M}[i,j])}.
1070 Veja também @code{map}, @code{fullmap}, @code{fullmapl}, e @code{apply}.
1072 @c NEED EXAMPLE HERE
1073 @end deffn
1075 @deffn {Função} matrixp (@var{expr})
1076 Retorna @code{true} se @var{expr} é uma matriz, de outra forma retorna @code{false}.
1078 @end deffn
1080 @defvr {Variável de opção} matrix_element_add
1081 Valor por omissão: @code{+}
1083 @code{matrix_element_add} é a operação
1084 invocada em lugar da adição em uma multiplicação de matrizes.
1085 A @code{matrix_element_add} pode ser atribuído qualquer operador n-ário
1086 (que é, uma função que manuseia qualquer número de argumentos).
1087 Os valores atribuídos podem ser o nome de um operador entre aspas duplas,
1088 o nome da função,
1089 ou uma expressão lambda.
1091 Veja também @code{matrix_element_mult} e @code{matrix_element_transpose}.
1093 Exemplo:
1095 @example
1096 (%i1) matrix_element_add: "*"$
1097 (%i2) matrix_element_mult: "^"$
1098 (%i3) aa: matrix ([a, b, c], [d, e, f]);
1099 [ a b c ]
1100 (%o3) [ ]
1101 [ d e f ]
1102 (%i4) bb: matrix ([u, v, w], [x, y, z]);
1103 [ u v w ]
1104 (%o4) [ ]
1105 [ x y z ]
1106 (%i5) aa . transpose (bb);
1107 [ u v w x y z ]
1108 [ a b c a b c ]
1109 (%o5) [ ]
1110 [ u v w x y z ]
1111 [ d e f d e f ]
1112 @end example
1114 @end defvr
1116 @defvr {Variável de opção} matrix_element_mult
1117 Valor por omissão: @code{*}
1119 @code{matrix_element_mult} é a operação
1120 invocada em lugar da multiplicação em uma multiplicação de matrizes.
1121 A @code{matrix_element_mult} pode ser atribuído qualquer operador binário.
1122 O valor atribuído pode ser o nome de um operador entre aspas duplas,
1123 o nome de uma função,
1124 ou uma expressão lambda.
1126 O operador do ponto @code{.} é uma escolha útil em alguns contextos.
1128 Veja também @code{matrix_element_add} e @code{matrix_element_transpose}.
1130 Exemplo:
1132 @example
1133 (%i1) matrix_element_add: lambda ([[x]], sqrt (apply ("+", x)))$
1134 (%i2) matrix_element_mult: lambda ([x, y], (x - y)^2)$
1135 (%i3) [a, b, c] . [x, y, z];
1136 2 2 2
1137 (%o3) sqrt((c - z) + (b - y) + (a - x) )
1138 (%i4) aa: matrix ([a, b, c], [d, e, f]);
1139 [ a b c ]
1140 (%o4) [ ]
1141 [ d e f ]
1142 (%i5) bb: matrix ([u, v, w], [x, y, z]);
1143 [ u v w ]
1144 (%o5) [ ]
1145 [ x y z ]
1146 (%i6) aa . transpose (bb);
1147 [ 2 2 2 ]
1148 [ sqrt((c - w) + (b - v) + (a - u) ) ]
1149 (%o6) Col 1 = [ ]
1150 [ 2 2 2 ]
1151 [ sqrt((f - w) + (e - v) + (d - u) ) ]
1153 [ 2 2 2 ]
1154 [ sqrt((c - z) + (b - y) + (a - x) ) ]
1155 Col 2 = [ ]
1156 [ 2 2 2 ]
1157 [ sqrt((f - z) + (e - y) + (d - x) ) ]
1158 @end example
1160 @end defvr
1162 @defvr {Variável de opção} matrix_element_transpose
1163 Valor por omissão: @code{false}
1165 @code{matrix_element_transpose} é a operação
1166 aplicada a cada elemento de uma matriz quando for uma transposta.
1167 A @code{matrix_element_mult} pode ser atribuído qualquer operador unário.
1168 O valor atribuído pode ser nome de um operador entre aspas duplas,
1169 o nome de uma função,
1170 ou uma expressão lambda.
1172 Quando @code{matrix_element_transpose} for igual a @code{transpose},
1173 a função @code{transpose} é aplicada a todo elemento.
1174 Quando @code{matrix_element_transpose} for igual a @code{nonscalars},
1175 a função @code{transpose} é aplicada a todo elemento não escalar.
1176 Se algum elemento é um átomo, a opção @code{nonscalars} aplica
1177 @code{transpose} somente se o átomo for declarado não escalar,
1178 enquanto a opção @code{transpose} sempre aplica @code{transpose}.
1180 O valor padrão, @code{false}, significa nenhuma operação é aplicada.
1182 Veja também @code{matrix_element_add} e @code{matrix_element_mult}.
1184 Exemplos:
1186 @example
1187 (%i1) declare (a, nonscalar)$
1188 (%i2) transpose ([a, b]);
1189 [ transpose(a) ]
1190 (%o2) [ ]
1191 [ b ]
1192 (%i3) matrix_element_transpose: nonscalars$
1193 (%i4) transpose ([a, b]);
1194 [ transpose(a) ]
1195 (%o4) [ ]
1196 [ b ]
1197 (%i5) matrix_element_transpose: transpose$
1198 (%i6) transpose ([a, b]);
1199 [ transpose(a) ]
1200 (%o6) [ ]
1201 [ transpose(b) ]
1202 (%i7) matrix_element_transpose: lambda ([x], realpart(x) - %i*imagpart(x))$
1203 (%i8) m: matrix ([1 + 5*%i, 3 - 2*%i], [7*%i, 11]);
1204 [ 5 %i + 1 3 - 2 %i ]
1205 (%o8) [ ]
1206 [ 7 %i 11 ]
1207 (%i9) transpose (m);
1208 [ 1 - 5 %i - 7 %i ]
1209 (%o9) [ ]
1210 [ 2 %i + 3 11 ]
1211 @end example
1213 @end defvr
1215 @c IS THIS THE ONLY MATRIX TRACE FUNCTION ??
1216 @deffn {Função} mattrace (@var{M})
1217 Retorna o traço (que é, a soma dos elementos sobre a diagonal principal) da
1218 matriz quadrada @var{M}.
1220 @code{mattrace} é chamada por @code{ncharpoly},
1221 uma alternativa para @code{charpoly} do Maxima.
1222 @c UMM, HOW IS THAT RELEVANT HERE ??
1224 @code{load ("nchrpl")} chama essa função.
1226 @end deffn
1228 @deffn {Função} minor (@var{M}, @var{i}, @var{j})
1229 Retorna o @var{i}, @var{j} menor do elemento localizado na linha @var{i} coluna @var{j} da matriz @var{M}. Que é @var{M}
1230 com linha @var{i} e coluna @var{j} ambas removidas.
1232 @end deffn
1234 @deffn {Função} ncexpt (@var{a}, @var{b})
1235 Se uma expressão exponencial não comutativa é muito
1236 alta para ser mostrada como @code{@var{a}^^@var{b}} aparecerá como @code{ncexpt (@var{a},@var{b})}.
1238 @code{ncexpt} não é o nome de uma função ou operador;
1239 o nome somente aparece em saídas, e não é reconhecido em entradas.
1241 @end deffn
1243 @deffn {Função} ncharpoly (@var{M}, @var{x})
1244 Retorna o polinómio característico da matriz @var{M}
1245 com relação a @var{x}. Essa é uma alternativa para @code{charpoly} do Maxima.
1247 @code{ncharpoly} trabalha pelo cálculo dos traços das potências na dada matriz,
1248 que são sabidos serem iguais a somas de potências das raízes do
1249 polinómio característico. Para essas quantidade a função
1250 simétrica das raízes pode ser calculada, que nada mais são que
1251 os coeficientes do polinómio característico. @code{charpoly} trabalha
1252 @c SHOULD THAT BE "m" INSTEAD OF "a" IN THE NEXT LINE ??
1253 formatando o determinante de @code{@var{x} * ident [n] - a}. Dessa forma @code{ncharpoly} é vencedor,
1254 por exemplo, no caso de largas e densas matrizes preencidas com inteiros,
1255 desde que isso evite inteiramente a aritmética polinomial.
1257 @code{load ("nchrpl")} loads this file.
1259 @end deffn
1261 @deffn {Função} newdet (@var{M}, @var{n})
1262 Calcula o determinante de uma matriz ou array @var{M} pelo
1263 algoritmo da árvore menor de Johnson-Gentleman.
1264 @c UGH -- ARRAYS ARE SUCH A MESS
1265 O argumento @var{n} é a ordem; isso é opcional se @var{M} for uma matriz.
1267 @end deffn
1269 @c NEEDS CLARIFICATION AND EXAMPLES
1270 @defvr {Declaração} nonscalar
1271 Faz átomos ser comportarem da mesma forma que uma lista ou matriz em relação ao
1272 operador do ponto.
1274 @end defvr
1276 @deffn {Função} nonscalarp (@var{expr})
1277 Retorna @code{true} se @var{expr} é um não escalar, i.e., isso contém
1278 átomos declarados como não escalares, listas, ou matrizes.
1280 @end deffn
1282 @deffn {Função} permanent (@var{M}, @var{n})
1283 Calcula o permanente da matriz @var{M}. Um permanente
1284 é como um determinante mas sem mudança de sinal.
1286 @end deffn
1288 @deffn {Função} rank (@var{M})
1289 Calcula o posto da matriz @var{M}. Que é, a ordem do
1290 mais largo determinante não singular de @var{M}.
1292 @c STATEMENT NEEDS CLARIFICATION
1293 @var{rank} pode retornar uma
1294 resposta ruim se não puder determinar que um elemento da matriz que é
1295 equivalente a zero é realmente isso.
1297 @end deffn
1299 @defvr {Variável de opção} ratmx
1300 Valor por omissão: @code{false}
1302 Quando @code{ratmx} é @code{false}, adição, subtração,
1303 e multiplicação para determinantes e matrizes são executados na
1304 representação dos elementos da matriz e fazem com que o resultado da
1305 inversão de matrizes seja esquerdo na representação geral.
1307 Quando @code{ratmx} é @code{true},
1308 as 4 operações mencionadas acima são executadas na forma CRE e o
1309 resultado da matriz inversa é dado na forma CRE. Note isso pode
1310 fazer com que os elementos sejam expandidos (dependendo da escolha de @code{ratfac})
1311 o que pode não ser desejado sempre.
1313 @end defvr
1315 @deffn {Função} row (@var{M}, @var{i})
1316 retorna a @var{i}'ésima linha da matriz @var{M}.
1317 O valor de retorno é uma matriz.
1319 @end deffn
1321 @defvr {Variável de opção} scalarmatrixp
1322 Valor por omissão: @code{true}
1324 Quando @code{scalarmatrixp} é @code{true}, então sempre que uma matriz 1 x 1
1325 é produzida como um resultado de cálculos o produto do ponto de matrizes
1326 é simplificado para um escalar, a saber o elemento solitário da matriz.
1328 Quando @code{scalarmatrixp} é @code{all},
1329 então todas as matrizes 1 x 1 serão simplificadas para escalares.
1331 Quando @code{scalarmatrixp} é @code{false}, matrizes 1 x 1 não são simplificadas para escalares.
1333 @end defvr
1335 @c I WONDER WHAT THIS IS ABOUT
1336 @deffn {Função} scalefactors (@var{coordinatetransform})
1337 Aqui coordinatetransform
1338 avalia para a forma [[expresão1, expresão2, ...],
1339 indeterminação1, indeterminação2, ...], onde indeterminação1,
1340 indeterminação2, etc. são as variáveis de coordenadas curvilíneas e
1341 onde a escolha de componentes cartesianas retangulares é dada em termos das
1342 coordenadas curvilíneas por [expresão1, expresão2, ...].
1343 @code{coordinates} é escolhida para o vector [indeterminação1, indeterminação2,...],
1344 e @code{dimension} é escolhida para o comprimento desse vector. SF[1], SF[2],
1345 ..., SF[DIMENSION] são escohidos para factores de escala de coordenada, e @code{sfprod}
1346 é escohido para o produto desse factores de escala. Inicialmente, @code{coordinates}
1347 é [X, Y, Z], @code{dimension} é 3, e SF[1]=SF[2]=SF[3]=SFPROD=1,
1348 correspondendo a coordenadas Cartesianas retangulares 3-dimensional.
1349 Para expandir uma expresão dentro de componentes físicos no sistema de coordenadas
1350 corrente , existe uma função com uso da forma
1351 @c SOME TEXT HAS GONE MISSING HERE
1353 @end deffn
1355 @deffn {Função} setelmx (@var{x}, @var{i}, @var{j}, @var{M})
1356 Atribue @var{x} para o (@var{i}, @var{j})'ésimo elemento da matriz @var{M},
1357 e retorna a matriz alterada.
1359 @code{@var{M} [@var{i}, @var{j}]: @var{x}} tem o mesmo efeito,
1360 mas retorna @var{x} em lugar de @var{M}.
1362 @end deffn
1364 @deffn {Função} similaritytransform (@var{M})
1365 @deffnx {Função} simtran (@var{M})
1366 @code{similaritytransform} calcula uma transformação homotética da matriz @code{M}.
1367 Isso retorna uma lista que é a saída do
1368 comando @code{uniteigenvectors}. Em adição se o sinalizador @code{nondiagonalizable}
1369 é @code{false} duas matrizes globais @code{leftmatrix} e @code{rightmatrix} são calculadas.
1370 Essas matrizes possuem a propriedade de
1371 @code{leftmatrix . @var{M} . rightmatrix} é uma matriz diagonal com os autovalores
1372 de @var{M} sobre a diagonal. Se @code{nondiagonalizable} é @code{true} as matrizes esquerda e
1373 direita não são computadas.
1375 Se o sinalizador @code{hermitianmatrix} é @code{true}
1376 então @code{leftmatrix} é o conjugado complexo da transposta de
1377 @code{rightmatrix}. De outra forma @code{leftmatrix} é a inversa de @code{rightmatrix}.
1379 @code{rightmatrix} é a matriz cujas colunas são os autovectores
1380 unitários de @var{M}. Os outros sinalizadores (veja @code{eigenvalues} e
1381 @code{eigenvectors}) possuem o mesmo efeito desde que
1382 @code{similaritytransform} chama as outras funções no pacote com o objectivo de
1383 estar habilitado para a forma @code{rightmatrix}.
1385 @code{load ("eigen")} chama essa função.
1387 @code{simtran} é um sin@^onimo para @code{similaritytransform}.
1389 @end deffn
1391 @defvr {Variável de opção} sparse
1392 Valor por omissão: @code{false}
1394 Quando @code{sparse} é @code{true}, e se @code{ratmx} é @code{true}, então @code{determinant}
1395 usará rotinas especiais para calcular determinantes esparsos.
1397 @end defvr
1399 @deffn {Função} submatrix (@var{i_1}, ..., @var{i_m}, @var{M}, @var{j_1}, ..., @var{j_n})
1400 @deffnx {Função} submatrix (@var{i_1}, ..., @var{i_m}, @var{M})
1401 @deffnx {Função} submatrix (@var{M}, @var{j_1}, ..., @var{j_n})
1402 Retorna uma nova matriz formada pela
1403 matrix @var{M} com linhas @var{i_1}, ..., @var{i_m} excluídas, e colunas @var{j_1}, ..., @var{j_n} excluídas.
1405 @end deffn
1407 @deffn {Função} transpose (@var{M})
1408 Retorna a transposta de @var{M}.
1410 Se @var{M} é uma matriz, o valor de retorno é outra matriz @var{N}
1411 tal que @code{N[i,j] = M[j,i]}.
1413 Se @var{M} for uma lista, o valor de retorno é uma matrix @var{N}
1414 de @code{length (m)} linhas e 1 coluna, tal que @code{N[i,1] = M[i]}.
1416 De outra forma @var{M} é um símbolo,
1417 e o valor de retorno é uma expressão substantiva @code{'transpose (@var{M})}.
1419 @end deffn
1421 @deffn {Função} triangularize (@var{M})
1422 Retorna a maior forma triangular da matriz @code{M}, como produzido através da eliminação de Gauss.
1423 O valor de retorno é o mesmo que @code{echelon},
1424 excepto que o o coeficiente lider não nulo em cada linha não é normalizado para 1.
1426 @code{lu_factor} e @code{cholesky} são outras funções que retornam matrizes triangularizadas.
1428 @c ===beg===
1429 @c M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
1430 @c triangularize (M);
1431 @c ===end===
1432 @example
1433 (%i1) M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
1434 [ 3 7 aa bb ]
1435 [ ]
1436 (%o1) [ - 1 8 5 2 ]
1437 [ ]
1438 [ 9 2 11 4 ]
1439 (%i2) triangularize (M);
1440 [ - 1 8 5 2 ]
1441 [ ]
1442 (%o2) [ 0 - 74 - 56 - 22 ]
1443 [ ]
1444 [ 0 0 626 - 74 aa 238 - 74 bb ]
1445 @end example
1447 @end deffn
1449 @deffn {Função} uniteigenvectors (@var{M})
1450 @deffnx {Função} ueivects (@var{M})
1451 Calcula autovectores unitários da matriz @var{M}.
1452 O valor de retorno é uma lista de listas, a primeiro sublista é a
1453 saída do comando @code{eigenvalues}, e as outras sublistas são
1454 os autovectores unitários da matriz correspondente a esses autovalores
1455 respectivamente.
1457 @c COPY DESCRIPTIONS OF THOSE FLAGS HERE
1458 Os sinalizadores mencionados na descrição do
1459 comando @code{eigenvectors} possuem o mesmo efeito aqui também.
1461 Quando @code{knowneigvects} é @code{true}, o pacote @code{eigen} assume
1462 que os autovectores da matriz são conhecidos para o utilizador são
1463 armazenados sob o nome global @code{listeigvects}. @code{listeigvects} pode ser ecolhido
1464 para uma lista similar à saída do comando @code{eigenvectors}.
1466 @c FOLLOWING PARAGRAPH IS IN NEED OF SERIOUS CLARIFICATION
1467 Se @code{knowneigvects} é escolhido para @code{true} e a lista de autovectores é dada a
1468 escolha do sinalizador @code{nondiagonalizable} pode não estar correcta. Se esse é
1469 o caso por favor ecolha isso para o valor correcto. O autor assume que
1470 o utilizador sabe o que está fazendo e que não tentará diagonalizar uma
1471 matriz cujos autovectores não geram o mesmo espaço vectorial de
1472 dimensão apropriada.
1474 @code{load ("eigen")} chama essa função.
1476 @code{ueivects} é um sin@^onimo para @code{uniteigenvectors}.
1478 @end deffn
1480 @deffn {Função} unitvector (@var{x})
1481 @deffnx {Função} uvect (@var{x})
1482 Retorna @math{@var{x}/norm(@var{x})};
1483 isso é um vector unitário na mesma direção que @var{x}.
1485 @code{load ("eigen")} chama essa função.
1487 @code{uvect} é um sin@^onimo para @code{unitvector}.
1489 @end deffn
1491 @c NEEDS A LOT OF WORK: MAKE SURE THAT ALL VECTOR SIMPLIFICATION FLAGS HAVE A DESCRIPTION HERE
1492 @deffn {Função} vectorsimp (@var{expr})
1493 Aplica simplificações e expansões conforme
1494 os seguintes sinalizadores globais:
1496 @code{expandall}, @code{expanddot}, @code{expanddotplus}, @code{expandcross}, @code{expandcrossplus},
1497 @code{expandcrosscross}, @code{expandgrad}, @code{expandgradplus}, @code{expandgradprod},
1498 @code{expanddiv}, @code{expanddivplus}, @code{expanddivprod}, @code{expandcurl}, @code{expandcurlplus},
1499 @code{expandcurlcurl}, @code{expandlaplacian}, @code{expandlaplacianplus},
1500 e @code{expandlaplacianprod}.
1502 Todos esses sinalizadores possuem valor padrão @code{false}. O sufixo @code{plus} refere-se a
1503 utilização aditivamente ou distribuitivamente. O sufixo @code{prod} refere-se a
1504 expansão para um operando que é qualquer tipo de produto.
1506 @table @code
1507 @item expandcrosscross
1508 Simplifica @math{p ~ (q ~ r)} para @math{(p . r)*q - (p . q)*r}.
1509 @item expandcurlcurl
1510 Simplifica @math{curl curl p} para @math{grad div p + div grad p}.
1511 @item expandlaplaciantodivgrad
1512 Simplifica @math{laplacian p} para @math{div grad p}.
1513 @item expandcross
1514 Habilita @code{expandcrossplus} e @code{expandcrosscross}.
1515 @item expandplus
1516 Habilita @code{expanddotplus}, @code{expandcrossplus}, @code{expandgradplus},
1517 @code{expanddivplus}, @code{expandcurlplus}, e @code{expandlaplacianplus}.
1518 @item expandprod
1519 Habilita @code{expandgradprod}, @code{expanddivprod}, e @code{expandlaplacianprod}.
1520 @end table
1522 @c EXPLAIN THE IMPORT OF THIS STATEMENT
1523 Esses sinalizadores foram todos declarados @code{evflag}.
1525 @c SEEMS SOME TEXT HAS GONE MISSING HERE; COMMENT OUT FRAGMENT PENDING
1526 @c RECOVERY AND/OR RECONSTRUCTION OF THIS PARAGRAPH
1527 @c For orthogonal curvilinear coordinates, the global variables
1528 @c COORDINATES[[X,Y,Z]], DIMENSION[3], SF[[1,1,1]], and SFPROD[1] são set
1529 @c by the function invocation
1531 @end deffn
1533 @defvr {Variável de opção} vect_cross
1534 Valor por omissão: @code{false}
1536 @c WHAT DOES THIS MEAN EXACTLY ??
1537 Quando @code{vect_cross} é @code{true}, isso permite DIFF(X~Y,T) trabalhar onde
1538 ~ é definido em SHARE;VECT (onde VECT_CROSS é escolhido para @code{true}, de qualqeur modo.)
1540 @end defvr
1542 @deffn {Função} zeromatrix (@var{m}, @var{n})
1543 Retorna um matriz @var{m} por @var{n}, com todos os elementos sendo zero.
1545 @end deffn
1547 @defvr {Símbolo especial} [
1548 @defvrx {Símbolo especial} ]
1549 @ifinfo
1550 @fnindex Delimitador de Lista
1551 @fnindex Operador de Subscrito
1552 @end ifinfo
1553 @code{[} e @code{]} marcam o omeço e o fim, respectivamente, de uma lista.
1555 @code{[} e @code{]} também envolvem os subscritos de
1556 uma lista, array, array desordenado, ou função array.
1558 Exemplos:
1560 @example
1561 (%i1) x: [a, b, c];
1562 (%o1) [a, b, c]
1563 (%i2) x[3];
1564 (%o2) c
1565 (%i3) array (y, fixnum, 3);
1566 (%o3) y
1567 (%i4) y[2]: %pi;
1568 (%o4) %pi
1569 (%i5) y[2];
1570 (%o5) %pi
1571 (%i6) z['foo]: 'bar;
1572 (%o6) bar
1573 (%i7) z['foo];
1574 (%o7) bar
1575 (%i8) g[k] := 1/(k^2+1);
1576 1
1577 (%o8) g := ------
1578 k 2
1579 k + 1
1580 (%i9) g[10];
1581 1
1582 (%o9) ---
1583 101
1584 @end example
1586 @end defvr