[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

25. Matrizes e Álgebra Linear


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

25.1 Introdução a Matrizes e Álgebra Linear


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

25.1.1 Ponto

O operador . representa multiplicação não comutativa e produto escalar. Quando os operandos são matrizes 1-coluna ou 1-linha a e b, a expresão a.b é equivalente a sum (a[i]*b[i], i, 1, length(a)). Se a e b não são complexos, isso é o produto escalar, também chamado produto interno ou produto do ponto, de a e b. O produto escalar é definido como conjugate(a).b quando a e b são complexos; innerproduct no pacote eigen fornece o produto escalar complexo.

Quando os operandos são matrizes mais gerais, o produto é a matriz produto a e b. O número de linhas de b deve ser igual ao número de colunas de a, e o resultado tem número de linhas igual ao número de linhas de a e número de colunas igual ao número de colunas de b.

Para distinguir . como um operador aritmético do ponto decimal em um número em ponto flutuante, pode ser necessário deixar espaços em cada lado. Por exemplo, 5.e3 é 5000.0 mas 5 . e3 é 5 vezes e3.

Existem muitos sinalizadores que governam a simplificação de expresões envolvendo ., a saber dot, dot0nscsimp, dot0simp, dot1simp, dotassoc, dotconstrules, dotdistrib, dotexptsimp, dotident, e dotscrules.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

25.1.2 Vetores

vect é um pacote de funções para análise vectorial. load ("vect") chama esse pacote, e demo ("vect") permite visualizar uma demonstração.

O pacote de análise vectorial pode combinar e simplificar expresões simbólicas incluindo produtos dos pontos e productos dos x, juntamente com o gradiente, divergencia, torção, e operadores Laplacianos. A distribuição desses operadores sobre adições ou produtos é governada por muitos sinalizadores, como são várias outras expansões, incluindo expansão dentro de componentes em qualquer sistema de coordenadas ortogonais. Existem também funções para derivar o escalar ou vector potencial de um campo.

O pacote vect contém essas funções: vectorsimp, scalefactors, express, potential, e vectorpotential.

Atenção: o pacote vect declara o operador ponto . como sendo um operador comutativo.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

25.1.3 auto

O pacote eigen contém muitas funções devotadas para a computação simbólica de autovalores e autovectores. Maxima chama o pacote automaticamente se uma das funções eigenvalues ou eigenvectors é invocada. O pacote pode ser chamado explicitamente com load ("eigen").

demo ("eigen") mostra uma demonstração das compatibilidades desse pacote. batch ("eigen") executa a mesma demonstração, mas sem lembretes de utilizador entre sucessivas computações.

As funções no pacote eigen são innerproduct, unitvector, columnvector, gramschmidt, eigenvalues, eigenvectors, uniteigenvectors, e similaritytransform.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

25.2 Definições para Matrizes e Álgebra Linear

Função: addcol (M, list_1, ..., list_n)

Anexa a(s) coluna(s) dadas por uma ou mais listas (ou matrizes) sobre a matriz M.

Função: addrow (M, list_1, ..., list_n)

Anexa a(s) linha(s) dadas por uma ou mais listas (ou matrizes) sobre a matriz M.

Função: adjoint (M)

Retorna a matriz adjunta da matriz M. A matriz adjunta é a transposta da matriz dos cofactores de M.

Função: augcoefmatrix ([eqn_1, ..., eqn_m], [x_1, ..., x_n])

Retorna a matriz dos coeficientes aumentada para as variáveis x_1, ..., x_n do sistema de equações lineares eqn_1, ..., eqn_m. Essa é a matriz dos coeficientes com uma coluna anexada para os termos independentes em cada equação (i.e., esses termos não dependem de x_1, ..., x_n).

(%i1) m: [2*x - (a - 1)*y = 5*b, c + b*y + a*x = 0]$
(%i2) augcoefmatrix (m, [x, y]);
                       [ 2  1 - a  - 5 b ]
(%o2)                  [                 ]
                       [ a    b      c   ]
Função: charpoly (M, x)

Retorna um polinómio característico para a matriz M em relação à variável x. Que é, determinant (M - diagmatrix (length (M), x)).

(%i1) a: matrix ([3, 1], [2, 4]);
                            [ 3  1 ]
(%o1)                       [      ]
                            [ 2  4 ]
(%i2) expand (charpoly (a, lambda));
                           2
(%o2)                lambda  - 7 lambda + 10
(%i3) (programmode: true, solve (%));
(%o3)               [lambda = 5, lambda = 2]
(%i4) matrix ([x1], [x2]);
                             [ x1 ]
(%o4)                        [    ]
                             [ x2 ]
(%i5) ev (a . % - lambda*%, %th(2)[1]);
                          [ x2 - 2 x1 ]
(%o5)                     [           ]
                          [ 2 x1 - x2 ]
(%i6) %[1, 1] = 0;
(%o6)                     x2 - 2 x1 = 0
(%i7) x2^2 + x1^2 = 1;
                            2     2
(%o7)                     x2  + x1  = 1
(%i8) solve ([%th(2), %], [x1, x2]);
                  1               2
(%o8) [[x1 = - -------, x2 = - -------], 
               sqrt(5)         sqrt(5)

                                             1             2
                                    [x1 = -------, x2 = -------]]
                                          sqrt(5)       sqrt(5)
Função: coefmatrix ([eqn_1, ..., eqn_m], [x_1, ..., x_n])

Retorna a matriz dos coeficientes para as variáveis x_1, ..., x_n do sistema de equações lineares eqn_1, ..., eqn_m.

(%i1) coefmatrix([2*x-(a-1)*y+5*b = 0, b*y+a*x = 3], [x,y]);
                                 [ 2  1 - a ]
(%o1)                            [          ]
                                 [ a    b   ]
Função: col (M, i)

Reorna a i'ésima coluna da matriz M. O valor de retorno é uma matriz.

Função: columnvector (L)
Função: covect (L)

Retorna uma matriz de uma coluna e length (L) linhas, contendo os elementos da lista L.

covect é um sinônimo para columnvector.

load ("eigen") chama essa função.

Isso é útil se quiser usar partes das saídas das funções nesse pacote em cálculos matriciais.

Exemplo:

(%i1) load ("eigen")$
Warning - you are redefining the Macsyma function autovalores
Warning - you are redefining the Macsyma function autovectores
(%i2) columnvector ([aa, bb, cc, dd]);
                             [ aa ]
                             [    ]
                             [ bb ]
(%o2)                        [    ]
                             [ cc ]
                             [    ]
                             [ dd ]
Função: conjugate (x)

Retorna o conjugado complexo de x.

(%i1) declare ([aa, bb], real, cc, complex, ii, imaginary);

(%o1)                         done
(%i2) conjugate (aa + bb*%i);

(%o2)                      aa - %i bb
(%i3) conjugate (cc);

(%o3)                     conjugate(cc)
(%i4) conjugate (ii);

(%o4)                         - ii
(%i5) conjugate (xx + yy);

(%o5)             conjugate(yy) + conjugate(xx)
Função: copymatrix (M)

Retorna uma cópia da matriz M. Esse é o único para fazer uma copia separada copiando M elemento a elemento.

Note que uma atribuição de uma matriz para outra, como em m2: m1, não copia m1. Uma atribuição m2 [i,j]: x ou setelmx (x, i, j, m2 também modifica m1 [i,j]. criando uma cópia com copymatrix e então usando atribução cria uma separada e modificada cópia.

Função: determinant (M)

Calcula o determinante de M por um método similar à eliminação de Gauss.

A forma do resultado depende da escolha do comutador ratmx.

Existe uma rotina especial para calcular determinantes esparsos que é chamada quando os comutadores ratmx e sparse são ambos true.

Variável: detout

Valor por omissão: false

Quando detout é true, o determinante de uma matriz cuja inversa é calculada é factorado fora da inversa.

Para esse comutador ter efeito doallmxops e doscmxops deveram ambos serem false (veja suas transcrições). Alternativamente esses comutadores podem ser dados para ev o que faz com que os outros dois sejam escolhidos correctamente.

Exemplo:

(%i1) m: matrix ([a, b], [c, d]);
                            [ a  b ]
(%o1)                       [      ]
                            [ c  d ]
(%i2) detout: true$
(%i3) doallmxops: false$
(%i4) doscmxops: false$
(%i5) invert (m);
                          [  d   - b ]
                          [          ]
                          [ - c   a  ]
(%o5)                     ------------
                           a d - b c
Função: diagmatrix (n, x)

Retorna uma matriz diagonal de tamanho n por n com os elementos da diagonal todos iguais a x. diagmatrix (n, 1) retorna uma matriz identidade (o mesmo que ident (n)).

n deve avaliar para um inteiro, de outra forma diagmatrix reclama com uma mensagem de erro.

x pode ser qualquer tipo de expresão, incluindo outra matriz. Se x é uma matriz, isso não é copiado; todos os elementos da diagonal referem-se à mesma instância, x.

Variável: doallmxops

Valor por omissão: true

Quando doallmxops é true, todas as operações relacionadas a matrizes são realizadas. Quando isso é false então a escolha de comutadores individuais dot governam quais operações são executadas.

Variável: domxexpt

Valor por omissão: true

Quando domxexpt é true, uma matriz exponencial, exp (M) onde M é a matriz, é interpretada como uma matriz com elementos [i,j iguais a exp (m[i,j]). de outra forma exp (M) avalia para exp (ev(M).

domxexpt afecta todas as expresões da forma base^expoente onde base é uma expresão assumida escalar ou constante, e expoente é uma lista ou matriz.

Exemplo:

(%i1) m: matrix ([1, %i], [a+b, %pi]);
                         [   1    %i  ]
(%o1)                    [            ]
                         [ b + a  %pi ]
(%i2) domxexpt: false$
(%i3) (1 - c)^m;
                             [   1    %i  ]
                             [            ]
                             [ b + a  %pi ]
(%o3)                 (1 - c)
(%i4) domxexpt: true$
(%i5) (1 - c)^m;
                  [                      %i  ]
                  [    1 - c      (1 - c)    ]
(%o5)             [                          ]
                  [        b + a         %pi ]
                  [ (1 - c)       (1 - c)    ]
Variável de opção: domxmxops

Valor por omissão: true

Quando domxmxops é true, todas as operações matriz-matriz ou matriz-lista são realizadas (mas não operações escalar-matriz); se esse comutador é false tais operações não são.

Variável de opção: domxnctimes

Valor por omissão: false

Quando domxnctimes é true, produtos não comutativos de matrizes são realizados.

Variável de opção: dontfactor

Valor por omissão: []

dontfactor pode ser escolhido para uma lista de variáveis em relação a qual factoração não é para ocorrer. (A lista é inicialmente vazia.) Factoração também não pegará lugares com relação a quaisquer variáveis que são menos importantes, conforme a hierarquía de variável assumida para a forma expresão racional canónica (CRE), que essas na lista dontfactor.

Variável de opção: doscmxops

Valor por omissão: false

Quando doscmxops é true, operações escalar-matriz são realizadas.

Variável de opção: doscmxplus

Valor por omissão: false

Quando doscmxplus é true, operações escalar-matriz retornam uma matriz resultado. Esse comutador não é subsomado sob doallmxops.

Variável de opção: dot0nscsimp

Valor por omissão: true

Quando dot0nscsimp é true, um produto não comutativo de zero e um termo não escalar é simplificado para um produto comutativo.

Variável de opção: dot0simp

Valor por omissão: true

Quando dot0simp é true, um produto não comutativo de zero e um termo escalar é simplificado para um produto não comutativo.

Variável de opção: dot1simp

Valor por omissão: true

Quando dot1simp é true, um produto não comutativo de um e outro termo é simplificado para um produto comutativo.

Variável de opção: dotassoc

Valor por omissão: true

Quando dotassoc é true, uma expresão (A.B).C simplifica para A.(B.C).

Variável de opção: dotconstrules

Valor por omissão: true

Quando dotconstrules é true, um produto não comutativo de uma constante e outro termo é simplificado para um produto comutativo. Ativando esse sinalizador efectivamente activamos dot0simp, dot0nscsimp, e dot1simp também.

Variável de opção: dotdistrib

Valor por omissão: false

Quando dotdistrib é true, uma expresão A.(B + C) simplifica para A.B + A.C.

Variável de opção: dotexptsimp

Valor por omissão: true

Quando dotexptsimp é true, uma expresão A.A simplifica para A^^2.

Variável de opção: dotident

Valor por omissão: 1

dotident é o valor retornado por X^^0.

Variável de opção: dotscrules

Valor por omissão: false

Quando dotscrules é true, uma expresão A.SC ou SC.A simplifica para SC*A e A.(SC*B) simplifica para SC*(A.B).

Função: echelon (M)

Retorna a forma escalonada da matriz M, como produzido através da eliminação de Gauss. A forma escalonada é calculada de M por operações elementares de linha tais que o primeiro elemento não zero em cada linha na matriz resultante seja o número um e os elementos da coluna abaixo do primeiro número um em cada linha sejam todos zero.

triangularize também realiza eliminação de Gaussian, mas não normaliza o elemento líder não nulo em cada linha.

lu_factor e cholesky são outras funções que retornam matrizes triangularizadas.

(%i1) M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
                       [  3   7  aa  bb ]
                       [                ]
(%o1)                  [ - 1  8  5   2  ]
                       [                ]
                       [  9   2  11  4  ]
(%i2) echelon (M);
                  [ 1  - 8  - 5      - 2     ]
                  [                          ]
                  [         28       11      ]
                  [ 0   1   --       --      ]
(%o2)             [         37       37      ]
                  [                          ]
                  [              37 bb - 119 ]
                  [ 0   0    1   ----------- ]
                  [              37 aa - 313 ]
Função: eigenvalues (M)
Função: eivals (M)

Retorna uma lista de duas listas contendo os autovalores da matriz M. A primeira sublista do valor de retorno é a lista de autovalores da matriz, e a segunda sublista é a lista de multiplicidade dos autovalores na ordem correspondente.

eivals é um sinônimo de eigenvalues.

eigenvalues chama a função solve para achar as raízes do polinómio característico da matriz. Algumas vezes solve pode não estar habilitado a achar as raízes do polinómio; nesse caso algumas outras funções nesse pacote (except innerproduct, unitvector, columnvector e gramschmidt) não irão trabalhar.

Em alguns casos os autovalores achados por solve podem ser expresões complicadas. (Isso pode acontecer quando solve retorna uma expresão real não trivial para um autovalor que é sabidamente real.) Isso pode ser possível para simplificar os autovalores usando algumas outras funções.

O pacote eigen.mac é chamado automaticamente quando eigenvalues ou eigenvectors é referenciado. Se eigen.mac não tiver sido ainda chamado, load ("eigen") chama-o. Após ser chamado, todas as funções e variáveis no pacote estarão disponíveis.

Função: eigenvectors (M)
Função: eivects (M)

pegam uma matriz M como seu argumento e retorna uma lista de listas cuja primeira sublista é a saída de eigenvalues e as outras sublistas são os autovectores da matriz correspondente para esses autovalores respectivamente.

eivects é um sinônimo para eigenvectors.

O pacote eigen.mac é chamado automaticamente quando eigenvalues ou eigenvectors é referenciado. Se eigen.mac não tiver sido ainda chamado, load ("eigen") chama-o. Após ser chamado, todas as funções e variáveis no pacote estarão disponíveis.

Os sinalizadores que afectam essa função são:

nondiagonalizable é escolhido para true ou false dependendo de se a matriz é não diagonalizável ou diagonalizável após o retorno de eigenvectors.

hermitianmatrix quando true, faz com que os autovectores degenerados da matriz Hermitiana sejam ortogonalizados usando o algoritmo de Gram-Schmidt.

knowneigvals quando true faz com que o pacote eigen assumir que os autovalores da matriz são conhecidos para o utilizador e armazenados sob o nome global listeigvals. listeigvals poderá ser escolhido para uma lista similar à saída de eigenvalues.

A função algsys é usada aqui para resolver em relação aos autovectores. Algumas vezes se os autovalores estão ausêntes, algsys pode não estar habilitado a achar uma solução. Em alguns casos, isso pode ser possível para simplificar os autovalores por primeiro achando e então usando o comando eigenvalues e então usando outras funções para reduzir os autovalores a alguma coisa mais simples. Continuando a simplificação, eigenvectors pode ser chamada novamente com o sinalizador knowneigvals escolhido para true.

Função: ematrix (m, n, x, i, j)

Retorna uma matriz m por n, todos os elementos da qual são zero excepto para o elemento [i, j] que é x.

Função: entermatrix (m, n)

Retorna uma matriz m por n, lendo os elementos interativamente.

Se n é igual a m, Maxima pergunta pelo tipo de matriz (diagonal, simétrica, antisimétrica, ou genérica) e por cada elemento. Cada resposta é terminada por um ponto e vírgula ; ou sinal de dólar $.

Se n não é igual a m, Maxima pergunta por cada elemento.

Os elementos podem ser quaisquer expressões, que são avaliadas. entermatrix avalia seus argumentos.

(%i1) n: 3$
(%i2) m: entermatrix (n, n)$

Is the matriz  1.  Diagonal  2.  Symmetric  3.  Antisymmetric  4.  General
Answer 1, 2, 3 or 4 : 
1$
Row 1 Column 1: 
(a+b)^n$
Row 2 Column 2: 
(a+b)^(n+1)$
Row 3 Column 3: 
(a+b)^(n+2)$

Matriz entered.
(%i3) m;
                [        3                     ]
                [ (b + a)      0         0     ]
                [                              ]
(%o3)           [                  4           ]
                [    0      (b + a)      0     ]
                [                              ]
                [                            5 ]
                [    0         0      (b + a)  ]
Função: genmatrix (a, i_2, j_2, i_1, j_1)
Função: genmatrix (a, i_2, j_2, i_1)
Função: genmatrix (a, i_2, j_2)

Retorna uma matriz gerada de a, pegando o elemento a[i_1,j_1] como o elemento do canto superior esquerdo e a[i_2,j_2] como o elemento do canto inferior directo da matriz. Aqui a é um array declarado (criado através de array mas não por meio de make_array) ou um array não declarado, ou uma função array, ou uma expressão lambda de dois argumentos. (Uma funçãO array é criado como outras funções com := ou define, mas os argumentos são colocados entre colchêtes em lugar de parêntesis.)

Se j_1 é omitido, isso é assumido ser igual a i_1. Se ambos j_1 e i_1 são omitidos, ambos são assumidos iguais a 1.

Se um elemento seleccionado i,j de um array for indefinido, a matriz conterá um elemento simbólico a[i,j].

Exemplos:

(%i1) h [i, j] := 1 / (i + j - 1);
                                    1
(%o1)                  h     := ---------
                        i, j    i + j - 1
(%i2) genmatrix (h, 3, 3);
                           [    1  1 ]
                           [ 1  -  - ]
                           [    2  3 ]
                           [         ]
                           [ 1  1  1 ]
(%o2)                      [ -  -  - ]
                           [ 2  3  4 ]
                           [         ]
                           [ 1  1  1 ]
                           [ -  -  - ]
                           [ 3  4  5 ]
(%i3) array (a, fixnum, 2, 2);
(%o3)                           a
(%i4) a [1, 1] : %e;
(%o4)                          %e
(%i5) a [2, 2] : %pi;
(%o5)                          %pi
(%i6) genmatrix (a, 2, 2);
                           [ %e   0  ]
(%o6)                      [         ]
                           [ 0   %pi ]
(%i7) genmatrix (lambda ([i, j], j - i), 3, 3);
                         [  0    1   2 ]
                         [             ]
(%o7)                    [ - 1   0   1 ]
                         [             ]
                         [ - 2  - 1  0 ]
(%i8) genmatrix (B, 2, 2);
                        [ B      B     ]
                        [  1, 1   1, 2 ]
(%o8)                   [              ]
                        [ B      B     ]
                        [  2, 1   2, 2 ]
Função: gramschmidt (x)
Função: gschmit (x)

Realiza o algoritmo de ortonalização de Gram-Schmidt sobre x, seja ela uma matriz ou uma lista de listas. x não é modificado por gramschmidt.

Se x é uma matriz, o algoritmo é aplicado para as linhas de x. Se x é uma lista de listas, o algoritmo é aplicado às sublistas, que devem ter igual números de elementos. Nos dois casos, o valor de retorno é uma lista de listas, as sublistas das listas são ortogonais e gera o mesmo spaço que x. Se a dimensão do conjunto gerador de x é menor que o número de linhas ou sublistas, algumas sublistas do valor de retorno são zero.

factor é chamada a cada estágio do algoritmo para simplificar resultados intermédios. Como uma consequência, o valor de retorno pode conter inteiros factorados.

gschmit (nota ortográfica) é um sinônimo para gramschmidt.

load ("eigen") chama essa função.

Exemplo:

(%i1) load ("eigen")$
Warning - you are redefining the Macsyma function autovalores
Warning - you are redefining the Macsyma function autovectores
(%i2) x: matrix ([1, 2, 3], [9, 18, 30], [12, 48, 60]);
                         [ 1   2   3  ]
                         [            ]
(%o2)                    [ 9   18  30 ]
                         [            ]
                         [ 12  48  60 ]
(%i3) y: gramschmidt (x);
                       2      2            4     3
                      3      3   3 5      2  3  2  3
(%o3)  [[1, 2, 3], [- ---, - --, ---], [- ----, ----, 0]]
                      2 7    7   2 7       5     5
(%i4) i: innerproduct$
(%i5) [i (y[1], y[2]), i (y[2], y[3]), i (y[3], y[1])];
(%o5)                       [0, 0, 0]
Função: ident (n)

Retorna uma matriz identidade n por n.

Função: innerproduct (x, y)
Função: inprod (x, y)

Retorna o produto interno (também chamado produto escalar ou produto do ponto) de x e y, que são listas de igual comprimento, ou ambas matrizes 1-coluna ou 1-linha de igual comprimento. O valor de retorno é conjugate (x) . y, onde . é o operador de multiplicação não comutativa.

load ("eigen") chama essa função.

inprod é um sinônimo para innerproduct.

Função: invert (M)

Retorna a inversa da matriz M. A inversa é calculada pelo método adjunto.

Isso permite a um utilizador calcular a inversa de uma matriz com entradas bfloat ou polinómios com coeficientes em ponto flutuante sem converter para a forma CRE.

Cofactores são calculados pela função determinant, então se ratmx é false a inversa é calculada sem mudar a representação dos elementos.

A implementação corrente é ineficiente para matrizes de alta ordem.

Quando detout é true, o determinante é factorado fora da inversa.

Os elementos da inversa não são automaticamente expandidos. Se M tem elementos polinomiais, melhor aparência de saída pode ser gerada por expand (invert (m)), detout. Se isso é desejável para ela divisão até pelo determinante pode ser excelente por xthru (%) ou alternativamente na unha por

expe (adjoint (m)) / expand (determinant (m))
invert (m) := adjoint (m) / determinant (m)

Veja ^^ (expoente não comutativo) para outro método de inverter uma matriz.

Variável de opção: lmxchar

Valor por omissão: [

lmxchar é o caractere mostrado como o delimitador esquerdo de uma matriz. Veja também rmxchar.

Exemplo:

(%i1) lmxchar: "|"$
(%i2) matrix ([a, b, c], [d, e, f], [g, h, i]);
                           | a  b  c ]
                           |         ]
(%o2)                      | d  e  f ]
                           |         ]
                           | g  h  i ]
Função: matrix (row_1, ..., row_n)

Retorna uma matriz retangular que tem as linhas row_1, ..., row_n. Cada linha é uma lista de expressões. Todas as linhas devem ter o mesmo comprimento.

As operações + (adição), - (subtração), * (multiplicação), e / (divisão), são realizadas elemento por elemento quando os operandos são duas matrizes, um escalar e uma matriz, ou uma matriz e um escalar. A operação ^ (exponenciação, equivalentemente **) é realizada elemento por elemento se os operandos são um escalar e uma matriz ou uma matriz e um escalar, mas não se os operandos forem duas matrizes. Todos as operações são normalmente realizadas de forma completa, incluindo . (multiplicação não comutativa).

Multiplicação de matrizes é representada pelo operador de multiplicação não comutativa .. O correspondente operador de exponenciação não comutativa é ^^. Para uma matriz A, A.A = A^^2 e A^^-1 é a inversa de A, se existir.

Existem comutadores para controlar a simplificação de expresões envolvendo operações escalar e matriz-lista. São eles doallmxops, domxexpt domxmxops, doscmxops, e doscmxplus.

Existem opções adicionais que são relacionadas a matrizes. São elas: lmxchar, rmxchar, ratmx, listarith, detout, scalarmatrix, e sparse.

Existe um número de funções que pegam matrizes como argumentos ou devolvem matrizes como valor de retorno. Veja eigenvalues, eigenvectors, determinant, charpoly, genmatrix, addcol, addrow, copymatrix, transpose, echelon, e rank.

Exemplos:

(%i1) x: matrix ([17, 3], [-8, 11]);
                           [ 17   3  ]
(%o1)                      [         ]
                           [ - 8  11 ]
(%i2) y: matrix ([%pi, %e], [a, b]);
                           [ %pi  %e ]
(%o2)                      [         ]
                           [  a   b  ]
(%i3) x + y;
                      [ %pi + 17  %e + 3 ]
(%o3)                 [                  ]
                      [  a - 8    b + 11 ]
(%i4) x - y;
                      [ 17 - %pi  3 - %e ]
(%o4)                 [                  ]
                      [ - a - 8   11 - b ]
(%i5) x * y;
                        [ 17 %pi  3 %e ]
(%o5)                   [              ]
                        [ - 8 a   11 b ]
(%i6) x / y;
                        [ 17       - 1 ]
                        [ ---  3 %e    ]
                        [ %pi          ]
(%o6)                   [              ]
                        [   8    11    ]
                        [ - -    --    ]
                        [   a    b     ]
(%i7) x ^ 3;
                         [ 4913    27  ]
(%o7)                    [             ]
                         [ - 512  1331 ]
(%i8) exp(y); 
                         [   %pi    %e ]
                         [ %e     %e   ]
(%o8)                    [             ]
                         [    a     b  ]
                         [  %e    %e   ]
(%i9) x ^ y;
                                [ %pi  %e ]
                                [         ]
                                [  a   b  ]
                     [ 17   3  ]
(%o9)                [         ]
                     [ - 8  11 ]
(%i10) x . y;
                  [ 3 a + 17 %pi  3 b + 17 %e ]
(%o10)            [                           ]
                  [ 11 a - 8 %pi  11 b - 8 %e ]
(%i11) y . x;
                [ 17 %pi - 8 %e  3 %pi + 11 %e ]
(%o11)          [                              ]
                [  17 a - 8 b     11 b + 3 a   ]
(%i12) x ^^ 3;
                        [  3833   1719 ]
(%o12)                  [              ]
                        [ - 4584  395  ]
(%i13) %e ^^ y;
                         [   %pi    %e ]
                         [ %e     %e   ]
(%o13)                   [             ]
                         [    a     b  ]
                         [  %e    %e   ]
(%i14) x ^^ -1;
                         [ 11      3  ]
                         [ ---  - --- ]
                         [ 211    211 ]
(%o14)                   [            ]
                         [  8    17   ]
                         [ ---   ---  ]
                         [ 211   211  ]
(%i15) x . (x ^^ -1);
                            [ 1  0 ]
(%o15)                      [      ]
                            [ 0  1 ]
Função: matrixmap (f, M)

Retorna uma matriz com elemento i,j igual a f(M[i,j]).

Veja também map, fullmap, fullmapl, e apply.

Função: matrixp (expr)

Retorna true se expr é uma matriz, de outra forma retorna false.

Variável de opção: matrix_element_add

Valor por omissão: +

matrix_element_add é a operação invocada em lugar da adição em uma multiplicação de matrizes. A matrix_element_add pode ser atribuído qualquer operador n-ário (que é, uma função que manuseia qualquer número de argumentos). Os valores atribuídos podem ser o nome de um operador entre aspas duplas, o nome da função, ou uma expressão lambda.

Veja também matrix_element_mult e matrix_element_transpose.

Exemplo:

(%i1) matrix_element_add: "*"$
(%i2) matrix_element_mult: "^"$
(%i3) aa: matrix ([a, b, c], [d, e, f]);
                           [ a  b  c ]
(%o3)                      [         ]
                           [ d  e  f ]
(%i4) bb: matrix ([u, v, w], [x, y, z]);
                           [ u  v  w ]
(%o4)                      [         ]
                           [ x  y  z ]
(%i5) aa . transpose (bb);
                     [  u  v  w   x  y  z ]
                     [ a  b  c   a  b  c  ]
(%o5)                [                    ]
                     [  u  v  w   x  y  z ]
                     [ d  e  f   d  e  f  ]
Variável de opção: matrix_element_mult

Valor por omissão: *

matrix_element_mult é a operação invocada em lugar da multiplicação em uma multiplicação de matrizes. A matrix_element_mult pode ser atribuído qualquer operador binário. O valor atribuído pode ser o nome de um operador entre aspas duplas, o nome de uma função, ou uma expressão lambda.

O operador do ponto . é uma escolha útil em alguns contextos.

Veja também matrix_element_add e matrix_element_transpose.

Exemplo:

(%i1) matrix_element_add: lambda ([[x]], sqrt (apply ("+", x)))$
(%i2) matrix_element_mult: lambda ([x, y], (x - y)^2)$
(%i3) [a, b, c] . [x, y, z];
                          2          2          2
(%o3)         sqrt((c - z)  + (b - y)  + (a - x) )
(%i4) aa: matrix ([a, b, c], [d, e, f]);
                           [ a  b  c ]
(%o4)                      [         ]
                           [ d  e  f ]
(%i5) bb: matrix ([u, v, w], [x, y, z]);
                           [ u  v  w ]
(%o5)                      [         ]
                           [ x  y  z ]
(%i6) aa . transpose (bb);
               [             2          2          2  ]
               [ sqrt((c - w)  + (b - v)  + (a - u) ) ]
(%o6)  Col 1 = [                                      ]
               [             2          2          2  ]
               [ sqrt((f - w)  + (e - v)  + (d - u) ) ]

                         [             2          2          2  ]
                         [ sqrt((c - z)  + (b - y)  + (a - x) ) ]
                 Col 2 = [                                      ]
                         [             2          2          2  ]
                         [ sqrt((f - z)  + (e - y)  + (d - x) ) ]
Variável de opção: matrix_element_transpose

Valor por omissão: false

matrix_element_transpose é a operação aplicada a cada elemento de uma matriz quando for uma transposta. A matrix_element_mult pode ser atribuído qualquer operador unário. O valor atribuído pode ser nome de um operador entre aspas duplas, o nome de uma função, ou uma expressão lambda.

Quando matrix_element_transpose for igual a transpose, a função transpose é aplicada a todo elemento. Quando matrix_element_transpose for igual a nonscalars, a função transpose é aplicada a todo elemento não escalar. Se algum elemento é um átomo, a opção nonscalars aplica transpose somente se o átomo for declarado não escalar, enquanto a opção transpose sempre aplica transpose.

O valor padrão, false, significa nenhuma operação é aplicada.

Veja também matrix_element_add e matrix_element_mult.

Exemplos:

(%i1) declare (a, nonscalar)$
(%i2) transpose ([a, b]);
                        [ transpose(a) ]
(%o2)                   [              ]
                        [      b       ]
(%i3) matrix_element_transpose: nonscalars$
(%i4) transpose ([a, b]);
                        [ transpose(a) ]
(%o4)                   [              ]
                        [      b       ]
(%i5) matrix_element_transpose: transpose$
(%i6) transpose ([a, b]);
                        [ transpose(a) ]
(%o6)                   [              ]
                        [ transpose(b) ]
(%i7) matrix_element_transpose: lambda ([x], realpart(x) - %i*imagpart(x))$
(%i8) m: matrix ([1 + 5*%i, 3 - 2*%i], [7*%i, 11]);
                     [ 5 %i + 1  3 - 2 %i ]
(%o8)                [                    ]
                     [   7 %i       11    ]
(%i9) transpose (m);
                      [ 1 - 5 %i  - 7 %i ]
(%o9)                 [                  ]
                      [ 2 %i + 3    11   ]
Função: mattrace (M)

Retorna o traço (que é, a soma dos elementos sobre a diagonal principal) da matriz quadrada M.

mattrace é chamada por ncharpoly, uma alternativa para charpoly do Maxima.

load ("nchrpl") chama essa função.

Função: minor (M, i, j)

Retorna o i, j menor do elemento localizado na linha i coluna j da matriz M. Que é M com linha i e coluna j ambas removidas.

Função: ncexpt (a, b)

Se uma expressão exponencial não comutativa é muito alta para ser mostrada como a^^b aparecerá como ncexpt (a,b).

ncexpt não é o nome de uma função ou operador; o nome somente aparece em saídas, e não é reconhecido em entradas.

Função: ncharpoly (M, x)

Retorna o polinómio característico da matriz M com relação a x. Essa é uma alternativa para charpoly do Maxima.

ncharpoly trabalha pelo cálculo dos traços das potências na dada matriz, que são sabidos serem iguais a somas de potências das raízes do polinómio característico. Para essas quantidade a função simétrica das raízes pode ser calculada, que nada mais são que os coeficientes do polinómio característico. charpoly trabalha formatando o determinante de x * ident [n] - a. Dessa forma ncharpoly é vencedor, por exemplo, no caso de largas e densas matrizes preencidas com inteiros, desde que isso evite inteiramente a aritmética polinomial.

load ("nchrpl") loads this file.

Função: newdet (M, n)

Calcula o determinante de uma matriz ou array M pelo algoritmo da árvore menor de Johnson-Gentleman. O argumento n é a ordem; isso é opcional se M for uma matriz.

Declaração: nonscalar

Faz átomos ser comportarem da mesma forma que uma lista ou matriz em relação ao operador do ponto.

Função: nonscalarp (expr)

Retorna true se expr é um não escalar, i.e., isso contém átomos declarados como não escalares, listas, ou matrizes.

Função: permanent (M, n)

Calcula o permanente da matriz M. Um permanente é como um determinante mas sem mudança de sinal.

Função: rank (M)

Calcula o posto da matriz M. Que é, a ordem do mais largo determinante não singular de M.

rank pode retornar uma resposta ruim se não puder determinar que um elemento da matriz que é equivalente a zero é realmente isso.

Variável de opção: ratmx

Valor por omissão: false

Quando ratmx é false, adição, subtração, e multiplicação para determinantes e matrizes são executados na representação dos elementos da matriz e fazem com que o resultado da inversão de matrizes seja esquerdo na representação geral.

Quando ratmx é true, as 4 operações mencionadas acima são executadas na forma CRE e o resultado da matriz inversa é dado na forma CRE. Note isso pode fazer com que os elementos sejam expandidos (dependendo da escolha de ratfac) o que pode não ser desejado sempre.

Função: row (M, i)

retorna a i'ésima linha da matriz M. O valor de retorno é uma matriz.

Variável de opção: scalarmatrixp

Valor por omissão: true

Quando scalarmatrixp é true, então sempre que uma matriz 1 x 1 é produzida como um resultado de cálculos o produto do ponto de matrizes é simplificado para um escalar, a saber o elemento solitário da matriz.

Quando scalarmatrixp é all, então todas as matrizes 1 x 1 serão simplificadas para escalares.

Quando scalarmatrixp é false, matrizes 1 x 1 não são simplificadas para escalares.

Função: scalefactors (coordinatetransform)

Aqui coordinatetransform avalia para a forma [[expresão1, expresão2, ...], indeterminação1, indeterminação2, ...], onde indeterminação1, indeterminação2, etc. são as variáveis de coordenadas curvilíneas e onde a escolha de componentes cartesianas retangulares é dada em termos das coordenadas curvilíneas por [expresão1, expresão2, ...]. coordinates é escolhida para o vector [indeterminação1, indeterminação2,...], e dimension é escolhida para o comprimento desse vector. SF[1], SF[2], ..., SF[DIMENSION] são escohidos para factores de escala de coordenada, e sfprod é escohido para o produto desse factores de escala. Inicialmente, coordinates é [X, Y, Z], dimension é 3, e SF[1]=SF[2]=SF[3]=SFPROD=1, correspondendo a coordenadas Cartesianas retangulares 3-dimensional. Para expandir uma expresão dentro de componentes físicos no sistema de coordenadas corrente , existe uma função com uso da forma

Função: setelmx (x, i, j, M)

Atribue x para o (i, j)'ésimo elemento da matriz M, e retorna a matriz alterada.

M [i, j]: x tem o mesmo efeito, mas retorna x em lugar de M.

Função: similaritytransform (M)
Função: simtran (M)

similaritytransform calcula uma transformação homotética da matriz M. Isso retorna uma lista que é a saída do comando uniteigenvectors. Em adição se o sinalizador nondiagonalizable é false duas matrizes globais leftmatrix e rightmatrix são calculadas. Essas matrizes possuem a propriedade de leftmatrix . M . rightmatrix é uma matriz diagonal com os autovalores de M sobre a diagonal. Se nondiagonalizable é true as matrizes esquerda e direita não são computadas.

Se o sinalizador hermitianmatrix é true então leftmatrix é o conjugado complexo da transposta de rightmatrix. De outra forma leftmatrix é a inversa de rightmatrix.

rightmatrix é a matriz cujas colunas são os autovectores unitários de M. Os outros sinalizadores (veja eigenvalues e eigenvectors) possuem o mesmo efeito desde que similaritytransform chama as outras funções no pacote com o objectivo de estar habilitado para a forma rightmatrix.

load ("eigen") chama essa função.

simtran é um sinônimo para similaritytransform.

Variável de opção: sparse

Valor por omissão: false

Quando sparse é true, e se ratmx é true, então determinant usará rotinas especiais para calcular determinantes esparsos.

Função: submatrix (i_1, ..., i_m, M, j_1, ..., j_n)
Função: submatrix (i_1, ..., i_m, M)
Função: submatrix (M, j_1, ..., j_n)

Retorna uma nova matriz formada pela matrix M com linhas i_1, ..., i_m excluídas, e colunas j_1, ..., j_n excluídas.

Função: transpose (M)

Retorna a transposta de M.

Se M é uma matriz, o valor de retorno é outra matriz N tal que N[i,j] = M[j,i].

Se M for uma lista, o valor de retorno é uma matrix N de length (m) linhas e 1 coluna, tal que N[i,1] = M[i].

De outra forma M é um símbolo, e o valor de retorno é uma expressão substantiva 'transpose (M).

Função: triangularize (M)

Retorna a maior forma triangular da matriz M, como produzido através da eliminação de Gauss. O valor de retorno é o mesmo que echelon, excepto que o o coeficiente lider não nulo em cada linha não é normalizado para 1.

lu_factor e cholesky são outras funções que retornam matrizes triangularizadas.

(%i1) M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
                       [  3   7  aa  bb ]
                       [                ]
(%o1)                  [ - 1  8  5   2  ]
                       [                ]
                       [  9   2  11  4  ]
(%i2) triangularize (M);
             [ - 1   8         5            2      ]
             [                                     ]
(%o2)        [  0   - 74     - 56         - 22     ]
             [                                     ]
             [  0    0    626 - 74 aa  238 - 74 bb ]
Função: uniteigenvectors (M)
Função: ueivects (M)

Calcula autovectores unitários da matriz M. O valor de retorno é uma lista de listas, a primeiro sublista é a saída do comando eigenvalues, e as outras sublistas são os autovectores unitários da matriz correspondente a esses autovalores respectivamente.

Os sinalizadores mencionados na descrição do comando eigenvectors possuem o mesmo efeito aqui também.

Quando knowneigvects é true, o pacote eigen assume que os autovectores da matriz são conhecidos para o utilizador são armazenados sob o nome global listeigvects. listeigvects pode ser ecolhido para uma lista similar à saída do comando eigenvectors.

Se knowneigvects é escolhido para true e a lista de autovectores é dada a escolha do sinalizador nondiagonalizable pode não estar correcta. Se esse é o caso por favor ecolha isso para o valor correcto. O autor assume que o utilizador sabe o que está fazendo e que não tentará diagonalizar uma matriz cujos autovectores não geram o mesmo espaço vectorial de dimensão apropriada.

load ("eigen") chama essa função.

ueivects é um sinônimo para uniteigenvectors.

Função: unitvector (x)
Função: uvect (x)

Retorna x/norm(x); isso é um vector unitário na mesma direção que x.

load ("eigen") chama essa função.

uvect é um sinônimo para unitvector.

Função: vectorsimp (expr)

Aplica simplificações e expansões conforme os seguintes sinalizadores globais:

expandall, expanddot, expanddotplus, expandcross, expandcrossplus, expandcrosscross, expandgrad, expandgradplus, expandgradprod, expanddiv, expanddivplus, expanddivprod, expandcurl, expandcurlplus, expandcurlcurl, expandlaplacian, expandlaplacianplus, e expandlaplacianprod.

Todos esses sinalizadores possuem valor padrão false. O sufixo plus refere-se a utilização aditivamente ou distribuitivamente. O sufixo prod refere-se a expansão para um operando que é qualquer tipo de produto.

expandcrosscross

Simplifica p ~ (q ~ r) para (p . r)*q - (p . q)*r.

expandcurlcurl

Simplifica curl curl p para grad div p + div grad p.

expandlaplaciantodivgrad

Simplifica laplacian p para div grad p.

expandcross

Habilita expandcrossplus e expandcrosscross.

expandplus

Habilita expanddotplus, expandcrossplus, expandgradplus, expanddivplus, expandcurlplus, e expandlaplacianplus.

expandprod

Habilita expandgradprod, expanddivprod, e expandlaplacianprod.

Esses sinalizadores foram todos declarados evflag.

Variável de opção: vect_cross

Valor por omissão: false

Quando vect_cross é true, isso permite DIFF(X~Y,T) trabalhar onde ~ é definido em SHARE;VECT (onde VECT_CROSS é escolhido para true, de qualqeur modo.)

Função: zeromatrix (m, n)

Retorna um matriz m por n, com todos os elementos sendo zero.

Símbolo especial: [
Símbolo especial: ]

[ e ] marcam o omeço e o fim, respectivamente, de uma lista.

[ e ] também envolvem os subscritos de uma lista, array, array desordenado, ou função array.

Exemplos:

(%i1) x: [a, b, c];
(%o1)                       [a, b, c]
(%i2) x[3];
(%o2)                           c
(%i3) array (y, fixnum, 3);
(%o3)                           y
(%i4) y[2]: %pi;
(%o4)                          %pi
(%i5) y[2];
(%o5)                          %pi
(%i6) z['foo]: 'bar;
(%o6)                          bar
(%i7) z['foo];
(%o7)                          bar
(%i8) g[k] := 1/(k^2+1);
                                  1
(%o8)                     g  := ------
                           k     2
                                k  + 1
(%i9) g[10];
                                1
(%o9)                          ---
                               101

[ << ] [ >> ]           [Top] [Contents] [Índice] [ ? ]

This document was generated by Jaime Villate on Outubro, 19 2014 using texi2html 1.76.