Aprenda Operações Matriciais com scipy.linalg | Álgebra Linear e Operações com Matrizes

Deslize para mostrar o menu

Quando é necessário realizar operações avançadas com matrizes em Python, o módulo scipy.linalg oferece um conjunto poderoso de ferramentas que ampliam e estendem as funcionalidades das funções de álgebra linear do NumPy. Embora o numpy.linalg seja adequado para muitas tarefas padrão, o scipy.linalg disponibiliza algoritmos adicionais, melhor desempenho para algumas operações e acesso a rotinas de baixo nível de bibliotecas como BLAS e LAPACK. Isso torna o scipy.linalg uma escolha preferencial para aplicações científicas e de engenharia que exigem cálculos robustos e eficientes com matrizes.


              1234567891011121314151617
            
import numpy as np
from scipy.linalg import blas

# Create two matrices
A = np.array([[1, 2], [3, 4]])
B = np.array([[2, 0], [1, 2]])

# Perform matrix multiplication using BLAS's dgemm (double-precision general matrix multiply)
C = blas.dgemm(alpha=1.0, a=A, b=B)

print("Matrix A:")
print(A)
print("\nMatrix B:")
print(B)
print("\nA multiplied by B using BLAS:")
print(C)

O exemplo de código mostra como multiplicar matrizes utilizando scipy.linalg.blas.dgemm, que é uma interface direta para a biblioteca BLAS. Essa função é especialmente útil quando se necessita de multiplicação de matrizes com alto desempenho, pois utiliza rotinas otimizadas de baixo nível.

Dadas as matrizes $A$ ( $m \times k$ ) e $B$ ( $k \times n$ ), o produto $C$ ( $m \times n$ ) é calculado como:

C_{ij} = \sum_{l=1}^k A_{il} B_{lj}

A função dgemm realiza essa operação de forma eficiente utilizando as rotinas BLAS. Também é possível escalar o resultado por meio do parâmetro alpha, de modo que a matriz calculada seja:

C = \alpha \cdot A \cdot B

Utilize dgemm quando for necessário controlar parâmetros específicos como fatores de escala (alpha) ou ao trabalhar com grandes arrays em que o desempenho é fundamental.


              1234567891011121314151617181920
            
import numpy as np
from scipy.linalg import lu, solve

# Define a square matrix and a right-hand side vector
A = np.array([[3, 1, 6], [2, 1, 3], [1, 1, 1]])
b = np.array([12, 7, 3])

# Perform LU decomposition
P, L, U = lu(A)
print("Permutation matrix P:")
print(P)
print("\nLower triangular matrix L:")
print(L)
print("\nUpper triangular matrix U:")
print(U)

# Solve the linear system Ax = b
x = solve(A, b)
print("\nSolution to Ax = b:")
print(x)

O exemplo de código demonstra a decomposição LU e a resolução de um sistema linear. A decomposição LU fatoriza uma matriz A em três matrizes P, L e U de forma que:

P A = L U

onde:

P é uma matriz de permutação que representa trocas de linhas;
L é uma matriz triangular inferior com uns na diagonal;
U é uma matriz triangular superior.

Essa fatoração auxilia na resolução eficiente de um sistema linear Ax = b. Primeiro, aplica-se a permutação ao lado direito:

P A x = L U x = P b

Seja y uma variável intermediária. Resolva o processo em duas etapas:

Substituição direta: Resolva $L y = P b$ para y;
Substituição retroativa: $U x = y$ para x.

Essa abordagem é especialmente útil quando é necessário resolver múltiplos sistemas com a mesma matriz A mas diferentes lados direitos, pois a decomposição LU precisa ser calculada apenas uma vez.

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 2. Capítulo 1

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Seção 2. Capítulo 1

Operações Matriciais com scipy.linalg

1. Qual é a principal diferença entre scipy.linalg e numpy.linalg?

2. Qual função você usaria para resolver um sistema de equações lineares no SciPy?

3. Qual é o objetivo da decomposição LU em álgebra linear?