Vetores e matrizes

Um vetor é uma lista simples de números, como uma direção no espaço ou um conjunto de quantidades. Uma matriz é uma lista de linhas. Esta página explica produtos escalar e vetorial, multiplicação de matrizes, determinantes, matrizes inversas, resolução de sistemas lineares e ferramentas numéricas de álgebra linear: autovalores e decomposições QR, LU e em valores singulares.

Use esses recursos em estudos de álgebra linear, geometria e transformações, ou em problemas com várias incógnitas relacionadas por equações lineares. Vetores e matrizes são listas comuns; por isso, tudo em Listas e estatísticas, como o acesso por índices, também se aplica.

Vetores

calcCopiar

dot([1, 2, 3], [4, 5, 6]) resulta em 32

dot([3, 4], [4, -3]) resulta em 0

cross([1, 0, 0], [0, 1, 0]) resulta em [0, 0, 1]

cross([1, 2, 3], [4, 5, 6]) resulta em [-3, 6, -3]

v = [3, 4]

sqrt(dot(v, v)) resulta em 5

dot multiplica os elementos correspondentes e soma os produtos. Um produto escalar igual a zero indica vetores perpendiculares, como [3, 4] e [4, -3]. cross retorna um vetor perpendicular aos dois vetores de entrada: o produto vetorial da direção x pela direção y resulta na direção z. O módulo de um vetor é a raiz quadrada do produto escalar dele por ele mesmo.

dot precisa de dois vetores do mesmo comprimento, e a cross precisa de dois vetores de três elementos. Para adicionar vetores ou dimensioná-los, use aritmética de lista comum: [1, 2] + [3, 4] é [4, 6] e 2 * [3, 4] é [6, 8]

Escrevendo e multiplicando matrizes

Escreva uma matriz como uma lista de linhas, cada linha em seus próprios colchetes:

calcCopiar

shape([[1, 2, 3], [4, 5, 6]]) resulta em [2, 3]

transpose([[1, 2, 3], [4, 5, 6]]) resulta em [[1, 4], [2, 5], [3, 6]]

identity(3) resulta em [[1, 0, 0], [0, 1, 0], [0, 0, 1]]

[[1, 2], [3, 4]] * [[5, 6], [7, 8]] resulta em [[19, 22], [43, 50]]

shape retorna [rows, columns]. transpose troca linhas por colunas. identity(n) é a matriz n por n que não altera outra matriz ao multiplicá-la.

* entre duas matrizes é a multiplicação da matriz, que precisa que a matriz esquerda tenha tantas colunas quanto a matriz direita tem linhas. Para multiplicar uma matriz por um vetor, escreva o vetor como uma coluna, um elemento por linha:

calcCopiar

# Rotate the point (3, 1) by 90° anticlockwise

rotate = [[0, -1], [1, 0]]

rotate * [[3], [1]] resulta em [[-1], [3]]

rotate * rotate resulta em [[-1, 0], [0, -1]]

Girar duas vezes por 90° dá meia volta, e é por isso que rotate * rotate vira ambos os sinais. Uma lista plana como [3, 1] não é aceita à direita de uma matriz. Se você tiver uma lista plana em um nome, transpose([v]) a transforma em uma coluna.

Matrizes da mesma forma podem ser adicionadas e subtraídas, e multiplicadas ou divididas por um valor numérico, como outras listas.

Algumas regras se aplicam a todas as operações de matriz:

• Cada linha deve ter o mesmo número de elementos.
• Os elementos devem ser números simples. Unidades e dinheiro não são aceitos.
• Uma matriz pode ter no máximo 32 linhas e 32 colunas.
• Não há abreviação de ponto e vírgula. Escreva [[1, 2], [3, 4]], não [1, 2; 3, 4].

Determinante, inversa, traço e posto

calcCopiar

M = [[2, 1], [5, 3]]

det(M) resulta em 1

inverse(M) resulta em [[3, -1], [-5, 2]]

M * inverse(M) resulta em [[1, 0], [0, 1]]

trace(M) resulta em 5

inverse([[2, 1], [1, 3]]) resulta em [[0.6, -0.2], [-0.2, 0.4]]

det([[1, 2], [2, 4]]) resulta em 0

rank([[1, 2, 3], [2, 4, 6]]) resulta em 1

det, inverse e trace (soma da diagonal) exigem uma matriz quadrada. Determinante zero indica uma matriz singular: suas linhas não são independentes e não existe inversa; por isso, inverse([[1, 2], [2, 4]]) produz erro. rank calcula o número de linhas independentes e também aceita matrizes não quadradas. Na última linha, a segunda linha da matriz é o dobro da primeira, portanto o posto é 1.

Essas quatro funções usam frações exatas em vez de aproximações decimais. Por isso, M * inverse(M) resulta exatamente na matriz identidade.

Resolva um sistema linear

Suponha que três cafés e dois chás custem £ 13,50, e um café e quatro chás custam £ 11,50. Coloque o número de cada bebida em uma linha por equação, com as colunas em ordem fixa (café, chá) e os totais em uma lista correspondente:

calcCopiar

solve_system([[3, 2], [1, 4]], [13.5, 11.5]) resulta em [3.1, 2.1]

A resposta segue a ordem das colunas: um café custa £3,10 e um chá, £2,10. Omita os símbolos de moeda, pois os elementos da matriz precisam ser números sem unidades.

solve_system(A, b) resolve A * x = b para encontrar x. Exige uma matriz quadrada, com uma linha por incógnita, e uma lista simples dos valores do lado direito com o mesmo tamanho. Usa frações exatas, portanto o resultado não tem erro de arredondamento.

Se as equações não determinarem uma única resposta, a mensagem informa que o sistema não tem solução única. Por exemplo, solve_system([[1, 2], [2, 4]], [3, 6]) falha porque a segunda equação é o dobro da primeira. solve_system resolve apenas equações lineares. Para uma equação como x^2 = 2, use solve, descrita em Somatórios, resolução de equações e cálculo.

Autovalores

calcCopiar

eigenvalues([[2, 1], [1, 2]]) resulta em [1, 3]

eigenvalues([[4, 1], [2, 3]]) resulta em [5, 2]

eigenvalues([[0, -1], [1, 0]]) resulta em [i, -i]

eigenvalues recebe uma matriz quadrada e retorna uma lista simples. Uma rotação de 90° não preserva nenhuma direção; seus autovalores são o par complexo i e -i. Veja Números complexos. A ordem dos elementos da lista não é garantida.

Decomposições: QR, LU e SVD

Cada decomposição retorna uma lista de matrizes. Use índices para retirar as peças:

calcCopiar

A = [[3, 0], [4, 5]]

parts = qr(A)

q = parts[0] resulta em [[0.6, -0.8], [0.8, 0.6]]

r = parts[1] resulta em [[5, 4], [0, 3]]

q * r resulta em [[3, 0], [4, 5]]

Multiplicar os fatores entre si reconstrói A, permitindo conferir a decomposição. Cálculos em ponto flutuante binário deixam pequenos resíduos de arredondamento, da ordem de 10⁻¹⁵, que Varlig exibe como 0 em listas e matrizes. Os valores armazenados preservam todos os dígitos; por isso, confira os resultados visualmente ou pela diferença entre eles, não com ==.

calcCopiar

lu([[2, 1], [4, 3]]) resulta em [[[0, 1], [1, 0]], [[1, 0], [0.5, 1]], [[4, 3], [0, -0.5]]]

lu retorna [P, L, U], onde P registra quaisquer trocas de linha e P * A é igual a L * U. Aqui as linhas foram trocadas para que o número maior, 4, seja usado primeiro.

calcCopiar

B = [[3, 1], [4, 7]]

f = svd(B)

u = f[0]

s = f[1]

vt = f[2]

u * [[s[0], 0], [0, s[1]]] * vt resulta em [[3, 1], [4, 7]]

svd([[3, 4]]) resulta em [[[1]], [5], [[0.6, 0.8]]]

svd retorna [U, s, Vt], onde s é uma lista plana de valores singulares, o maior primeiro. Em livros didáticos, B é igual a U * diag(s) * Vt. Não há função diag, então construa a matriz diagonal você mesmo, como em [[s[0], 0], [0, s[1]]].

Para matrizes não quadradas, qr e svd retornam os fatores na forma reduzida: em uma matriz 3 por 2, Q também é 3 por 2, em vez de 3 por 3.

O que é exato e o que é recusado

Soma, subtração e multiplicação de matrizes, multiplicação por um número, transpose, det e inverse usam frações exatas em todas as matrizes aceitas pelo Varlig. Não há arredondamento na entrada nem ao reutilizar o resultado em outro cálculo. Por isso, multiplicar uma matriz pela sua inversa retorna exatamente a matriz identidade:

calcCopiar

[[1, 2], [3, 4]] + [[10, 20], [30, 40]] resulta em [[11, 22], [33, 44]]

[[1, 2], [3, 4]] - [[1, 1], [1, 1]] resulta em [[0, 1], [2, 3]]

3 * [[1, 2], [3, 4]] resulta em [[3, 6], [9, 12]]

[[1, 2], [3, 4]] * [[0, 1], [1, 0]] resulta em [[2, 1], [4, 3]]

det([[1, 2], [3, 4]]) resulta em -2

inverse([[1, 2], [3, 4]]) resulta em [[-2, 1], [1.5, -0.5]]

inverse([[1, 2], [3, 4]]) * [[1, 2], [3, 4]] resulta em [[1, 0], [0, 1]]

Todas as condições são verificadas antes que uma resposta apareça, e a mensagem diz qual delas falhou:

calcCopiar

det([[1, 2, 3], [4, 5, 6]]) resulta em Unsupported: Expected a square matrix

inverse([[1, 2], [2, 4]]) resulta em Unsupported: Singular matrix has no inverse

[[1, 2], [3, 4]] + [[1, 2, 3], [4, 5, 6]] resulta em Unsupported: List dimensions do not match

[[1, 2, 3], [4, 5, 6]] * [[1, 2], [3, 4]] resulta em Unsupported: Matrix inner dimensions do not match

Os elementos de uma matriz precisam ser números sem unidades. Uma unidade, um valor monetário ou um número complexo em qualquer posição interrompe o cálculo, pois as operações de matriz não preservam esses tipos de valor:

calcCopiar

det([[1 kg, 2], [3, 4]]) resulta em Unsupported: Matrix entries must be plain numbers; units, money and complex values are not supported

Apenas uma lista de linhas é lida como uma matriz. Uma lista plana mantém seu próprio significado, então [1, 2] + [3, 4] ainda é o item por item [4, 6], e [1, 2] * [3, 4] ainda é um erro apontando para dot.

Para as regras de exatidão em equações, matrizes e estatísticas em um só lugar, consulte O que o mecanismo garante.

Algoritmos e limites

det, inverse, rank e solve_system funcionam com frações exatas, dentro dos limites da calculadora sobre o tamanho de um valor numérico. eigenvalues, qr, lu e svd funcionam em ponto flutuante binário, então suas respostas são aproximações próximas. Suas iterações param após 10.000 passos.

Matrizes cujas linhas são quase dependentes, como [[1, 1], [1, 1.0000001]], são chamadas de malcondicionadas. Pequenos erros de arredondamento crescem quando você trabalha com eles, portanto, decomposições e autovalores de tais matrizes podem perder precisão, e casos muito extremos podem exceder os limites numéricos e dar um erro.

As regras completas estão na referência matemática avançada.

Combinando os recursos

Três recibos de uma barraca de mercado listam quantas maçãs, bananas e laranjas foram compradas e o total pago, mas não os preços individuais:

calcCopiar

# Each row: apples, bananas, oranges

baskets = [[2, 3, 1], [1, 2, 3], [4, 1, 2]]

paid = [2.15, 2.70, 3.05]

det(baskets) resulta em 25

prices = solve_system(baskets, paid) resulta em [0.4, 0.25, 0.6]

# Check the prices against every receipt

baskets * transpose([prices]) resulta em [[2.15], [2.7], [3.05]]

# What would 5 apples, 2 bananas and 4 oranges cost?

dot([5, 2, 4], prices) resulta em 4.9

O determinante diferente de zero confirma que os recibos são suficientes para encontrar um conjunto de preços: maçãs a 40p, bananas a 25p e laranjas a 60p. Multiplicar as cestas pelos preços como uma coluna reproduz os totais, e dot precifica uma nova cesta em £4,90.