curso4.mw

Álgebra Linear  

Introdução 

Os comandos de Álgebra Linear estão agrupado no pacote LinearAlgebra, que deve ser carregado com o comando with: 

> restart

Normalmente, terminamos o comando de carregar pacotes com dois pontos para que suas funções  não sejam mostradas, especialmente quando se trata do pacote LinearAlgebra , pois ele possui uma quantidade grande de comandos. Para ter acesso à lista das funções do pacote e suas respectivas páginas de ajuda, devemos dar o comando ?LinearAlgebra ou clique com o mouse em cima do comando LinearAlgebra (em vermelho acima e pressione F2). Vamos começar descrevendo como definir matrizes. 

Definindo uma Matriz 

A matriz mais simples de definir é a matriz quadrada nula 

> with(LinearAlgebra); -1

> M := Matrix(3)
M := rtable(1 .. 3, 1 .. 3, [[0, 0, 0], [0, 0, 0], [0, 0, 0]], subtype = Matrix) (1.2.1)
 

Se queremos definir uma matriz que tem poucos elementos não nulos, podemos atribuir cada entrada, por exemplo 

> M[1, 3], M[3, 1] := 1, 1
1, 1 (1.2.2)
 

Note que agora M é a matriz 

> M
rtable(1 .. 3, 1 .. 3, [[0, 0, 1], [0, 0, 0], [1, 0, 0]], subtype = Matrix) (1.2.3)
 

Matrix é o principal comando definir matrizes Por exemplo  

> A := Matrix([[1, 2, 3], [4, 5, 6]])
A := rtable(1 .. 2, 1 .. 3, [[1, 2, 3], [4, 5, 6]], subtype = Matrix) (1.2.4)
 

> B := Matrix([[a, b], [d, e]])
B := rtable(1 .. 2, 1 .. 2, [[a, b], [d, e]], subtype = Matrix) (1.2.5)
 

Podemos fazer agora operações algébricas com as matrizes A e B 

> `+`(A, A)
rtable(1 .. 2, 1 .. 3, [[2, 4, 6], [8, 10, 12]], subtype = Matrix) (1.2.6)
 

> `+`(`*`(3, `*`(A)))
rtable(1 .. 2, 1 .. 3, [[3, 6, 9], [12, 15, 18]], subtype = Matrix) (1.2.7)
 

> Typesetting:-delayDotProduct(B, A)
rtable(1 .. 2, 1 .. 3, [[`+`(a, `*`(4, `*`(b))), `+`(`*`(2, `*`(a)), `*`(5, `*`(b))), `+`(`*`(3, `*`(a)), `*`(6, `*`(b)))], [`+`(d, `*`(4, `*`(e))), `+`(`*`(2, `*`(d)), `*`(5, `*`(e))), `+`(`*`(3, `*`... (1.2.8)
 

Note que usamos o produto usual ''*'' (na tela aparace , porém é um comando opcional) para multiplicação por escalar, e usamos a multiplicação não-comutativa ''.'' (na tela aparerce . ) para produto de matrizes. O produto comutativo não pode ser usado para matrizes 

> `*`(B, `*`(A))

Podemos também elevar uma matriz a um número inteiro. A potenciação por um número negativo quer dizer inversão da matriz e subsequente potenciação pelo módulo do número. Por exemplo (potência é feita com ^ ou ** por exemplo B^(-1)) 

Error, (in rtable/Product) invalid arguments

> inv_B := `/`(1, `*`(B))
inv_B := rtable(1 .. 2, 1 .. 2, [[`/`(`*`(e), `*`(`+`(`*`(a, `*`(e)), `-`(`*`(b, `*`(d)))))), `+`(`-`(`/`(`*`(b), `*`(`+`(`*`(a, `*`(e)), `-`(`*`(b, `*`(d))))))))], [`+`(`-`(`/`(`*`(d), `*`(`+`(`*`(a,... (1.2.9)
 

Vamos testar se inv_B é o inverso de B 

> Typesetting:-delayDotProduct(inv_B, B)
rtable(1 .. 2, 1 .. 2, [[`+`(`/`(`*`(a, `*`(e)), `*`(`+`(`*`(a, `*`(e)), `-`(`*`(b, `*`(d)))))), `-`(`/`(`*`(b, `*`(d)), `*`(`+`(`*`(a, `*`(e)), `-`(`*`(b, `*`(d)))))))), 0], [0, `+`(`/`(`*`(a, `*`(e)... (1.2.10)
 

Para simplificar cada elemento da matriz é necessário usar o comando Map 

> simplify(%)
rtable(1 .. 2, 1 .. 2, [[1, 0], [0, 1]], subtype = Matrix) (1.2.11)
 

Podemos modificar um elemento da matriz da seguinte forma 

> A[2, 1] := quatro
quatro (1.2.12)
 

> A
rtable(1 .. 2, 1 .. 3, [[1, 2, 3], [quatro, 5, 6]], subtype = Matrix) (1.2.13)
 

Quando uma matriz tem uma regra de formação, é possível repassar esta regra como terceiro argumento do comando Matrix. Os dois primeiros argumentos devem ser as dimensões da matriz. Vamos definir uma matriz de dimensão 3x4, onde o elemento <i,j> é dado por `/`(`*`(i), `*`(j)) (o operador é obtido entrando com - seguido de >, ou seja, ->): 

> Matrix(3, 4, proc (i, j) options operator, arrow; `/`(`*`(i), `*`(j)) end proc)
rtable(1 .. 3, 1 .. 4, [[1, `/`(1, 2), `/`(1, 3), `/`(1, 4)], [2, 1, `/`(2, 3), `/`(1, 2)], [3, `/`(3, 2), 1, `/`(3, 4)]], subtype = Matrix) (1.2.14)
 

Uma notação mais econômica para definir matrizes ou vetores é (as letras gregas devem se dadas por extenso: alpha, beta, gamma, delta. Para converter para notação matemática, escreva alpha e pressione ESC) 

> C := `<|>`(`<,>`(alpha, beta), `<,>`(gamma, delta))
C := rtable(1 .. 2, 1 .. 2, [[alpha, gamma], [beta, delta]], subtype = Matrix) (1.2.15)
 

As linhas são separadas pela barra vertical |, e cada  linha deve ficar dentro de < ... >. Veja mais detalhes em ?MVshortcuts. As operações mais usuais com matrizes são o cálculo do traço, matriz transposta, determinante e posto 

> Trace(C)
`+`(alpha, delta) (1.2.16)
 

> Transpose(C)
rtable(1 .. 2, 1 .. 2, [[alpha, beta], [gamma, delta]], subtype = Matrix) (1.2.17)
 

> Determinant(C)
`+`(`*`(alpha, `*`(delta)), `-`(`*`(beta, `*`(gamma)))) (1.2.18)
 

> Rank(C)
2 (1.2.19)
 

 

Matrizes Especiais 

Existem várias matrizes especiais que são usadas com frequência em Álgebra Linear. Muitas delas têm comandos específicos para gerá-las. Os comandos para definir matrizes especiais são 

 

BandMatrix ,   BezoutMatrix ,   CompanionMatrix ,   ConstantMatrix , 

DiagonalMatrix ,    GenerateMatrix ,   GivensRotationMatrix ,   

HankelMatrix , HilbertMatrix , HouseholderMatrix , IdentityMatrix , 

JordanBlockMatrix ,   RandomMatrix ,   ScalarMatrix , SylvesterMatrix ,  

ToeplitzMatrix , VandermondeMatrix ,   ZeroMatrix .                                             

 

Na maioria dos casos, podemos prever o que o comando faz pelo nome. Por exemplo, para definir uma matriz nula 4x4 

> ZeroMatrix(4)
rtable(1 .. 4, 1 .. 4, [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], subtype = Matrix) (1.3.1)
 

O comando DiagonalMatrix cria matrizes diagonal em blocos. A entrada deve ser uma lista de matrizes ou  escalares. 

> DiagonalMatrix([A, B, 1])
rtable(1 .. 5, 1 .. 6, [[1, 2, 3, 0, 0, 0], [quatro, 5, 6, 0, 0, 0], [0, 0, 0, a, b, 0], [0, 0, 0, d, e, 0], [0, 0, 0, 0, 0, 1]], subtype = Matrix) (1.3.2)
 

O comando GenerateMatrix é usado para construir uma matriz a partir dos coeficientes de um sistema de equações lineares. Considere o seguinte sistema 

> eqs := [`+`(`*`(3, `*`(a)), `*`(2, `*`(b)), `*`(3, `*`(c)), `-`(`*`(2, `*`(d)))) = 1, `+`(a, b, c) = 3, `+`(a, `*`(2, `*`(b)), c, `-`(d)) = 2]

> vars := [a, b, c, d]
 

(1.3.3)
 

Vamos fazer a seguinte atribuição dupla (a saída do comando GenerateMatrix é uma sequência com dois elementos) 

> A, v := GenerateMatrix(eqs, vars)
A, v := rtable(1 .. 3, 1 .. 4, [[3, 2, 3, -2], [1, 1, 1, 0], [1, 2, 1, -1]], subtype = Matrix), rtable(1 .. 3, [1, 3, 2], subtype = Vector[column]) (1.3.4)
 

Note que tanto A quanto v 

> A, v
rtable(1 .. 3, 1 .. 4, [[3, 2, 3, -2], [1, 1, 1, 0], [1, 2, 1, -1]], subtype = Matrix), rtable(1 .. 3, [1, 3, 2], subtype = Vector[column]) (1.3.5)
 

foram atribuidos pelas repectivas matrizes. A equação matricial correspondente ao sistema de equações pode ser obtida da seguinte forma usando o comando Vector 

> Typesetting:-delayDotProduct(A, Vector(vars)) = v
rtable(1 .. 3, [`+`(`*`(3, `*`(a)), `*`(2, `*`(b)), `*`(3, `*`(c)), `-`(`*`(2, `*`(d)))), `+`(a, b, c), `+`(a, `*`(2, `*`(b)), c, `-`(d))], subtype = Vector[column]) = rtable(1 .. 3, [1, 3, 2], subtyp... (1.3.6)
 

A opção augmented=true é uma forma alternativa de usar o comando GenerateMatrix 

> B := GenerateMatrix(eqs, vars, augmented = true)
B := rtable(1 .. 3, 1 .. 5, [[3, 2, 3, -2, 1], [1, 1, 1, 0, 3], [1, 2, 1, -1, 2]], subtype = Matrix) (1.3.7)
 

Nesse caso podermos repassar o resultado diretamente para o comando LinearSolve 

> LinearSolve(B)
rtable(1 .. 4, [`+`(1, `-`(_t[3])), 2, _t[3], 3], subtype = Vector[column]) (1.3.8)
 

A variável _t[3] é um parâmetro livre da solução (a variável t pode ser aparecer como  _t0[3] ou  _t1[3] dependendo se o comando for usado mais do que uma vez).  

 

O comando RandomMatrix serve para gerar matrizes randômicas. Vamos gerar uma matriz randômica triangular com elementos inteiros no intervalo 1..10. 

> randomize(); -1

> RandomMatrix(4, 4, generator = 1 .. 10, outputoptions = [shape = triangular[upper]])
rtable(1 .. 4, 1 .. 4, [[7, 5, 8, 5], [0, 9, 4, 4], [0, 0, 1, 10], [0, 0, 0, 2]], subtype = Matrix) (1.3.9)
 

O comando randomize( ) usa a hora corrente como semente para o algoritmo de randomização.  

Autovalores e Autovetores  

Os comandos relativos a cálculo de autovetores e autovalores são 

 

CharacteristicMatrix ,   CharacteristicPolynomial ,    Eigenvalues ,  

Eigenvectors ,    MinimalPolynomial .    

 

Vamos definir uma matriz 

> A := Matrix([[0, 1], [epsilon, 0]])
A := rtable(1 .. 2, 1 .. 2, [[0, 1], [varepsilon, 0]], subtype = Matrix) (1.4.1)
 

O comando Eigenvectors fornece uma sequência de 2 elementos, o primeiro corresponde aos autovalores, e o segundo corresponde aos autovetores (com colunas) 

> val, vec := Eigenvectors(A)
val, vec := rtable(1 .. 2, [sqrt(varepsilon), `+`(`-`(sqrt(varepsilon)))], subtype = Vector[column]), rtable(1 .. 2, 1 .. 2, [[`/`(1, `*`(sqrt(varepsilon))), `+`(`-`(`/`(1, `*`(sqrt(varepsilon)))))], ... (1.4.2)
 

Vamos selecionar o primeiro autovetor 

> v1 := vec[1 .. 2, 1]
v1 := rtable(1 .. 2, [`/`(1, `*`(sqrt(varepsilon))), 1], subtype = Vector[column]) (1.4.3)
 

e vamos confirmar que v1 de fato é o autovetor correspondente ao primeiro autovalor 

> simplify(`+`(Typesetting:-delayDotProduct(A, v1), `-`(`*`(val[1], `*`(v1)))))
rtable(1 .. 2, [0, 0], subtype = Vector[column]) (1.4.4)
 

Se a resposta do comando anterior não for o vetor nulo, use o comando simplify( ..., symbolic) que executa mais simplificações pois assume que a variáveis são reais 

> simplify(`+`(Typesetting:-delayDotProduct(A, v1), `-`(`*`(val[1], `*`(v1)))), symbolic)
rtable(1 .. 2, [0, 0], subtype = Vector[column]) (1.4.5)
 

Uma maneira alternativa de separar os diversos autovalores é usar a opção output=list 

> vecs := Eigenvectors(A, output = list)
vecs := [[sqrt(varepsilon), 1, {rtable(1 .. 2, [`/`(1, `*`(sqrt(varepsilon))), 1], subtype = Vector[column])}], [`+`(`-`(sqrt(varepsilon))), 1, {rtable(1 .. 2, [`+`(`-`(`/`(1, `*`(sqrt(varepsilon)))))... (1.4.6)
 

Neste caso a saída é uma lista de listas com o autovalor, sua multiplicidade e o conjunto de autovetores correspondentes. O conjunto tem mais de um elemento quando o autovalor é degenerado. O primeiro autovetor é selecionado da seguinte forma 

> vecs[1][3][1]
rtable(1 .. 2, [`/`(1, `*`(sqrt(varepsilon))), 1], subtype = Vector[column]) (1.4.7)
 

onde vecs[1][3][1] deve ser lido da seguinte maneira. vecs[1] é a primeira componente da lista vecs. vecs[1][3] é a terceira componente da lista vecs[1]. vecs[1][3][1] é o primeiro elemento do conjunto  vecs[1][3] .  

 

O polinômio característico é obtido com o comando CharacteristicPolynomial: 

> CharacteristicPolynomial(A, x)
`+`(`*`(`^`(x, 2)), `-`(epsilon)) (1.4.8)
 

O polinômio mínimo é obtido com o comando MinimalPolynomial: 

> MinimalPolynomial(A, x)
`+`(`*`(`^`(x, 2)), `-`(epsilon)) (1.4.9)
 

O polinômio mínimo é igual ao polinômio característico se todos os autovalores forem diferentes (multiplicidade 1), como é o caso acima. 

 

Manipulação Estrutural de Matrizes 

Os principais comandos para manipulação estrutural com matrizes são 

 

DeleteRow, DeleteColumn , Dimension, RowDimension, ColumnDimension ,      Map ,  

Row, Column ,     RowOperation, ColumnOperation ,    SubMatrix ,    Zip .           

 

A maioria dos nomes dos comandos acima falam por si só. As terminações ou prefixos Row e Column se referem a linha e coluna, respectivamente. Todos os comandos com prefixo Row têm seu equivalente com prefixo Column. O comando RowDimension, por exemplo, fornece o número de linhas da matriz enquanto que ColumnDimension fornece o número de colunas da matriz. Vejamos alguns exemplos dos comandos deste grupo.  

> A := Matrix(2, 3, proc (i, j) options operator, arrow; Lambda || i || j end proc)
A := rtable(1 .. 2, 1 .. 3, [[Lambda11, Lambda12, Lambda13], [Lambda21, Lambda22, Lambda23]], subtype = Matrix) (1.5.1)
 

> B := Matrix(2, 3, proc (i, j) options operator, arrow; lambda || i || j end proc)
B := rtable(1 .. 2, 1 .. 3, [[lambda11, lambda12, lambda13], [lambda21, lambda22, lambda23]], subtype = Matrix) (1.5.2)
 

Podemos juntar as matrizes A e B lateralmente 

> M1 := Matrix([A, B])
M1 := rtable(1 .. 2, 1 .. 6, [[Lambda11, Lambda12, Lambda13, lambda11, lambda12, lambda13], [Lambda21, Lambda22, Lambda23, lambda21, lambda22, lambda23]], subtype = Matrix) (1.5.3)
 

ou verticalmente 

> M2 := Matrix([[A], [B]])
M2 := rtable(1 .. 4, 1 .. 3, [[Lambda11, Lambda12, Lambda13], [Lambda21, Lambda22, Lambda23], [lambda11, lambda12, lambda13], [lambda21, lambda22, lambda23]], subtype = Matrix) (1.5.4)
 

Podemos extrair uma sub-matriz de uma matriz com o comando SubMatrix 

> M3 := SubMatrix(M2, 2 .. 3, 1 .. 3)
M3 := rtable(1 .. 2, 1 .. 3, [[Lambda21, Lambda22, Lambda23], [lambda11, lambda12, lambda13]], subtype = Matrix) (1.5.5)
 

Podemos multiplicar uma determinada linha de uma matriz por um escalar: 

> RowOperation(M3, 2, 10)
rtable(1 .. 2, 1 .. 3, [[Lambda21, Lambda22, Lambda23], [`+`(`*`(10, `*`(lambda11))), `+`(`*`(10, `*`(lambda12))), `+`(`*`(10, `*`(lambda13)))]], subtype = Matrix) (1.5.6)
 

Podemos apagar uma ou mais linhas com o comando DeleteRow. 

> DeleteRow(%, 1 .. 1)
rtable(1 .. 1, 1 .. 3, [[`+`(`*`(10, `*`(lambda11))), `+`(`*`(10, `*`(lambda12))), `+`(`*`(10, `*`(lambda13)))]], subtype = Matrix) (1.5.7)
 

O comando Zip é equivalente ao comando zip. O comando zip com z minúsculo atua basicamente em listas enquanto que Zip com Z maiúsculo atua em matrizes e vetores. Vejamos um exemplo 

> Zip(proc (x, y) options operator, arrow; {x, y} end proc, A, B)
rtable(1 .. 2, 1 .. 3, [[{Lambda11, lambda11}, {Lambda12, lambda12}, {Lambda13, lambda13}], [{Lambda21, lambda21}, {Lambda22, lambda22}, {Lambda23, lambda23}]], subtype = Matrix) (1.5.8)
 

O primeiro argumento do comando Zip deve ser uma função com 2 argumentos. Os valores de x  (primeiro argumento) são as componentes da matriz A, enquanto que os valores de y  (segundo argumento) são as componentes da matriz B. Se A e B têm a mesma dimensão, o resultado será uma nova matriz com a mesma dimensão. Se elas tem dimensões diferentes, a dimensão da matriz resultante vai depender de parâmetros adicionais do comando Zip. Veja o help on line neste caso. 

 

Cálculo Vetorial 

Os vetores linha são criados pelo comando Vector. 

> v1 := Vector([a, b, c])
v1 := rtable(1 .. 3, [a, b, c], subtype = Vector[column]) (1.6.1)
 

Por default, o vetor coluna é criado, o equivalente vetor linha é obtido com o comando 

> v1a := Vector[row]([a, b, c])
v1a := rtable(1 .. 3, [a, b, c], subtype = Vector[row]) (1.6.2)
 

Pode-se usar uma função para calcular cada elemento do vetor (semelhante ao método usado com matrizes, porém a função deve ter um argumento apenas) 

> v2 := Vector(3, proc (n) options operator, arrow; `^`(x, n) end proc)
v2 := rtable(1 .. 3, [x, `*`(`^`(x, 2)), `*`(`^`(x, 3))], subtype = Vector[column]) (1.6.3)
 

As operações aritméticas são realizadas usando os operadores usuais de soma e multiplicação. 

> `+`(v1, v2)
rtable(1 .. 3, [`+`(a, x), `+`(`*`(`^`(x, 2)), b), `+`(`*`(`^`(x, 3)), c)], subtype = Vector[column]) (1.6.4)
 

> `+`(`*`(2, `*`(v1)))
rtable(1 .. 3, [`+`(`*`(2, `*`(a))), `+`(`*`(2, `*`(b))), `+`(`*`(2, `*`(c)))], subtype = Vector[column]) (1.6.5)
 

Os principais comandos do pacote LinearAlgebra relacionados com vetores são: 

 

CrossProduct ,     Dimension ,     DotProduct ,     IsOrthogonal ,     MatrixVectorMultiply , 

Norm ,     Normalize ,    UnitVector ,    VectorAngle ,    Zip .   

 

Vamos ver exemplos de alguns deles. O produto escalar é calculado com o comando DotProduct. 

> DotProduct(v1, v2)
`+`(`*`(conjugate(a), `*`(x)), `*`(conjugate(b), `*`(`^`(x, 2))), `*`(conjugate(c), `*`(`^`(x, 3)))) (1.6.6)
 

Se v1 for um vetor coluna, o produto escalar será calculado usando o complexo conjugado de v1, como é o caso acima. Se v1 for um vetor linha, o produto escalar será calculado usando o complexo conjugado de v2.  

> DotProduct(v1a, v2)
`+`(`*`(conjugate(x), `*`(a)), `*`(`^`(conjugate(x), 2), `*`(b)), `*`(`^`(conjugate(x), 3), `*`(c))) (1.6.7)
 

Note que em qualquer caso não importa se v2 seja vetor linha ou vetor coluna. Para evitar o uso de complexo conjugado deve-se usar a opção conjugate=false. 

> DotProduct(v1, v2, conjugate = false)
`+`(`*`(c, `*`(`^`(x, 3))), `*`(b, `*`(`^`(x, 2))), `*`(a, `*`(x))) (1.6.8)
 

O produto exterior ou produto vetorial é calculado com o comando CrossProduct. 

> v3 := CrossProduct(v1, v2)
v3 := rtable(1 .. 3, [`+`(`*`(b, `*`(`^`(x, 3))), `-`(`*`(c, `*`(`^`(x, 2))))), `+`(`-`(`*`(a, `*`(`^`(x, 3)))), `*`(c, `*`(x))), `+`(`*`(a, `*`(`^`(x, 2))), `-`(`*`(b, `*`(x))))], subtype = Vector[co... (1.6.9)
 

Por definição, o vetor v3 é ortogonal a v1 e v2, como podemos facilmente verificar 

> simplify(DotProduct(v1, v3, conjugate = false))
0 (1.6.10)
 

> simplify(DotProduct(v2, v3, conjugate = false))
0 (1.6.11)
 

ou de forma análoga, podemos verificar que o ângulo entre v1 e v3 é  `+`(`*`(`/`(1, 2), `*`(Pi))) 

> simplify(VectorAngle(v1, v3, conjugate = false))
`+`(`*`(`/`(1, 2), `*`(Pi))) (1.6.12)
 

O módulo de um vetor é calculado pelo comando Norm com a opção Euclidean. 

> Norm(v1, Euclidean)
`*`(`^`(`+`(`*`(`^`(abs(a), 2)), `*`(`^`(abs(b), 2)), `*`(`^`(abs(c), 2))), `/`(1, 2))) (1.6.13)
 

O valor default da segunda opção é infinity. Neste caso a norma é definida da seguinte maneira: 

> Norm(v1, infinity)
max(abs(a), abs(b), abs(c)) (1.6.14)
 

ou seja, o resultado é o valor em módulo da maior componente. 

 

Um vetor pode ser normalizado com o comando Normalize. Como exemplo, vamos definir um vetor não normalizado e em seguida normalizá-lo. 

> v4 := `<,>`(1, 2, 3)
v4 := rtable(1 .. 3, [1, 2, 3], subtype = Vector[column]) (1.6.15)
 

> Normalize(v4, Euclidean)
rtable(1 .. 3, [`+`(`*`(`/`(1, 14), `*`(sqrt(14)))), `+`(`*`(`/`(1, 7), `*`(sqrt(14)))), `+`(`*`(`/`(3, 14), `*`(sqrt(14))))], subtype = Vector[column]) (1.6.16)
 

Naturalmente, o módulo do último resultado deve ser 1.  

> Norm(%, Euclidean)
1 (1.6.17)
 

Note que a opção Euclidean deve aparecer explicitamente em todos os cálculos envolvendo módulos de vetores.  

 

Os comandos para calcular gradiente, divergente, rotacional e laplaciano não fazem parte do pacote LinearAlgebra. Nesse caso é necessário carregar o pacote VectorCalculus 

> restart

Os comandos em questão são grad, diverge, curl e laplacian. Estes comandos devem ter no mínimo dois argumentos, onde o primeiro é uma função, ou melhor,  uma expressão que depende de certas variáveis, e o segundo uma lista de variáveis que representam as coordenadas. O sistema de coordenadas default é o sistema cartesiano. Vamos dar uma apelido para as expressões g(x, y, z) e h(x, y, g), e vamos calcular o gradiente, divergente e laplaciano de funções 

> with(VectorCalculus); -1

> alias(f = f(x, y, z), g = g(x, y, z), h = h(x, y, z))
f, g, h (1.6.18)
 

> Gradient(f, [x, y, z])
`+`(`*`(diff(f, x), `*`(`#mover(mi( (1.6.19)
 

> Divergence(%)
`+`(diff(diff(f, x), x), diff(diff(f, y), y), diff(diff(f, z), z)) (1.6.20)
 

> Laplacian(f, [x, y, z])
`+`(diff(diff(f, x), x), diff(diff(f, y), y), diff(diff(f, z), z)) (1.6.21)
 

O divergente e o rotacional devem ser aplicados a uma função vetorial. Note que a saída do comando Gradient é um função vetorial. 

> SetCoordinates(cartesian[x, y, z])
cartesian[x, y, z] (1.6.22)
 

> VectorField([f, g, h])
`+`(`*`(f, `*`(`#mover(mi( (1.6.23)
 

> Divergence(VectorField([f, g, h]))
`+`(diff(f, x), diff(g, y), diff(h, z)) (1.6.24)
 

> Curl(VectorField([f, g, h]))
`+`(`*`(`+`(diff(h, y), `-`(diff(g, z))), `*`(`#mover(mi( (1.6.25)
 

Podemos confirmar que o divergente do rotacional é zero  

> Divergence(%)
0 (1.6.26)
 

e, da mesma forma, confirmar que o rotacional do gradiente é o vetor nulo 

> Curl(Gradient(f))
`*`(0, `#mover(mi( (1.6.27)
 

Todas estas operações podem ser feitas em sistemas de coordenadas não-cartesianos. Vamos ver um exemplo de cálculo de gradiente no sistema de coordenadas esféricas: 

> f1 := `*`(`^`(r, 2), `*`(sin(theta), `*`(cos(phi))))
`*`(`^`(r, 2), `*`(sin(theta), `*`(cos(phi)))) (1.6.28)
 

> SetCoordinates(spherical[r, phi, theta]); 1
spherical[r, phi, theta] (1.6.29)
 

> Gradient(f1)
`+`(`*`(2, `*`(r, `*`(sin(theta), `*`(cos(phi), `*`(`#mover(mi( (1.6.30)
 

Além de coordenadas cartesianas, esféricas e cilíndricas que são as mais utilizadas, o Maple conhece mais de 40 sistemas de coordenadas em 2 e 3 dimensões. Para ter acesso a lista completa destes sistemas, pedimos ajuda da forma ?coords. 

Exercícios 

1.  Seja 

A = rtable(1 .. 4, 1 .. 4, [[0, 0, 1, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 1, 0, 0]], subtype = Matrix) 

Calcule: 

(a)  Typesetting:-delayDotProduct(Typesetting:-delayDotProduct(A, `/`(1, `*`(A))), D)eu o resultado esperado? 

(b)   

 

2. Resolva o sistema de equações 

`+`(`*`(2, `*`(x)), y, `-`(z)) = 2 

`+`(`*`(2, `*`(x)), `*`(2, `*`(y)), z) = 8 

`+`(x, `-`(y), `*`(2, `*`(z))) = 3 

usando o método de matrizes, ou seja, encontre a matriz M tal que M.Vector([x,y,z])=Vector([2,8,3]), calcule a matriz inversa e multiplique por Vector([2,8,3]). Verifique o resultado com solve. 

 

3. Ache duas soluções, que não sejam múltiplas uma da outra, do sistema `*`(A, `*`(x)) = b, onde 

A = rtable(1 .. 3, 1 .. 3, [[0, 2, 4], [1, -1, -3], [0, 1, 2]], subtype = Matrix), B = rtable(1 .. 3, [2, -1, 2], subtype = Vector[column]) 

(Tente usar somente as funções do pacote LinearAlgebra.) 

 

4. (a) Use o comando BandMatrix para gerar a matriz M(4) = rtable(1 .. 4, 1 .. 4, [[`+`(`*`(`^`(x, 2)), 1), x, 0, 0], [x, `+`(`*`(`^`(x, 2)), 1), x, 0], [0, x, `+`(`*`(`^`(x, 2)), 1), x], [0, 0, x, `+`(`*`(`^`(x, 2)), 1)]], subtype = Matrix) e calcule o determinante. 

 

(b) Repita o processo para matrizes de dimensões maiores com a mesma regra de formação. Observando os resultados, faça uma hipótese da forma do determinante de uma matriz M(n) de dimensão genérica n. Verifique a sua hipótese para um matrizes de várias dimensões.  

 

5. (a) Use o comando BandMatrix para gerar a matriz A(5) = rtable(1 .. 5, 1 .. 5, [[0, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1], [0, 0, 0, 0, 0]], subtype = Matrix) . 

 

(b) Use o Maple para determinar o menor n tal que `^`(A(5), n) seja a matriz nula. Generalize o resultado para matriz de dimensões maiores com a mesma regra de formação. 

 

6. Use uma função de 2 argumentos para definir uma matriz M 3x3 cujos elementos são M[i, j] = `/`(1, `*`(`^`(`+`(1, i), j))) . Ache os autovalores de M. 

7. O vetor rtable(1 .. 3, [1, 1, -1], subtype = Vector[column]) está no espaço gerado pelas colunas da matriz rtable(1 .. 3, 1 .. 3, [[1, 2, 3], [1, 1, 2], [0, 1, 1]], subtype = Matrix)?
O núcleo de uma matriz é o espaço vetorial gerado pelos autovetores associados ao autovalor zero. O vetor dado está no núcleo da matriz?
 

8. Mostre no Maple que o vetor rtable(1 .. 2, [cos(theta), sin(theta)], subtype = Vector[column]) (theta é um número real) tem norma 1. 

 

>