Próximo: Funções Afins, Anterior: Arrays [Conteúdo][Índice]
Próximo: Definições para Matrizes e Álgebra Linear, Anterior: Matrizes e Álgebra Linear, Acima: Matrizes e Álgebra Linear [Conteúdo][Índice]
Próximo: Vetores, Anterior: Introdução a Matrizes e Álgebra Linear, Acima: Introdução a Matrizes e Álgebra Linear [Conteúdo][Índice]
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.
Próximo: auto, Anterior: Ponto, Acima: Introdução a Matrizes e Álgebra Linear [Conteúdo][Índice]
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.
Anterior: Vetores, Acima: Introdução a Matrizes e Álgebra Linear [Conteúdo][Índice]
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.
Anterior: Introdução a Matrizes e Álgebra Linear, Acima: Matrizes e Álgebra Linear [Conteúdo][Índice]
Anexa a(s) coluna(s) dadas por uma ou mais listas (ou matrizes) sobre a matriz M.
Anexa a(s) linha(s) dadas por uma ou mais listas (ou matrizes) sobre a matriz M.
Retorna a matriz adjunta da matriz M. A matriz adjunta é a transposta da matriz dos cofactores de M.
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 ]
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)
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 ]
Reorna a i’ésima coluna da matriz M. O valor de retorno é uma matriz.
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 ]
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)
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.
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.
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
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.
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.
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) ]
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.
Valor por omissão: false
Quando domxnctimes é true, produtos não comutativos de
matrizes são realizados.
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.
Valor por omissão: false
Quando doscmxops é true, operações escalar-matriz são
realizadas.
Valor por omissão: false
Quando doscmxplus é true, operações escalar-matriz retornam
uma matriz resultado. Esse comutador não é subsomado sob doallmxops.
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.
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.
Valor por omissão: true
Quando dot1simp é true,
um produto não comutativo de um e
outro termo é simplificado para um produto comutativo.
Valor por omissão: true
Quando dotassoc é true, uma expresão (A.B).C simplifica para
A.(B.C).
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.
Valor por omissão: false
Quando dotdistrib é true, uma expresão A.(B + C) simplifica para A.B + A.C.
Valor por omissão: true
Quando dotexptsimp é true, uma expresão A.A simplifica para A^^2.
Valor por omissão: 1
dotident é o valor retornado por X^^0.
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).
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 ]
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.
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.
Retorna uma matriz m por n, todos os elementos da qual
são zero excepto para o elemento [i, j] que é x.
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) ]
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 ]
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]
Retorna uma matriz identidade n por n.
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.
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.
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 ]
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 ]
b^^m é o mesmo que b^m.
(%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 ]
Retorna uma matriz com elemento i,j igual a f(M[i,j]).
Veja também map, fullmap, fullmapl, e apply.
Retorna true se expr é uma matriz, de outra forma retorna false.
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 ]
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) ) ]
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 ]
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.
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.
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.
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.
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.
Faz átomos ser comportarem da mesma forma que uma lista ou matriz em relação ao operador do ponto.
Retorna true se expr é um não escalar, i.e., isso contém
átomos declarados como não escalares, listas, ou matrizes.
Calcula o permanente da matriz M. Um permanente é como um determinante mas sem mudança de sinal.
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.
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.
retorna a i’ésima linha da matriz M. O valor de retorno é uma matriz.
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.
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
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.
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.
Valor por omissão: false
Quando sparse é true, e se ratmx é true, então determinant
usará rotinas especiais para calcular determinantes esparsos.
Retorna uma nova matriz formada pela matrix M com linhas i_1, ..., i_m excluídas, e colunas j_1, ..., j_n excluídas.
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).
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 ]
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.
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.
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.
expandcrosscrossSimplifica p ~ (q ~ r) para (p . r)*q - (p . q)*r.
expandcurlcurlSimplifica curl curl p para grad div p + div grad p.
expandlaplaciantodivgradSimplifica laplacian p para div grad p.
expandcrossHabilita expandcrossplus e expandcrosscross.
expandplusHabilita expanddotplus, expandcrossplus, expandgradplus,
expanddivplus, expandcurlplus, e expandlaplacianplus.
expandprodHabilita expandgradprod, expanddivprod, e expandlaplacianprod.
Esses sinalizadores foram todos declarados evflag.
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.)
Retorna um matriz m por n, com todos os elementos sendo zero.
[ 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
Próximo: Funções Afins, Anterior: Arrays [Conteúdo][Índice]