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