Matrizes em Julia

Matriz

Matrizes são estruturas centrais em diversas aplicações científicas e computacionais, e Julia oferece ferramentas poderosas e eficientes para manipulá-las de forma intuitiva. Neste post, você aprenderá a criar matrizes, acessar elementos, realizar operações e explorar suas principais propriedades.

Autores
Afiliação

Caio Frare

Universidade Estadual de Campinas

Nicole Fredericci

Universidade Estadual de Campinas

Data de Publicação

26 de agosto de 2025

Introdução - o que são Matrizes?

Matrizes são estruturas matemáticas em formato tabular, organizadas em linhas e colunas, com operações bem definidas como adição, subtração, multiplicação e transposição. De maneira intuitiva, podem ser vistas como uma extensão bidimensional dos vetores. São amplamente utilizadas para armazenar e manipular dados, desempenhando papel central em estatística, econometria e aprendizado de máquina.

Neste post, você aprenderá a criar matrizes, acessar elementos, realizar operações e explorar suas principais propriedades. Também será apresentado, de forma breve, como utilizar o pacote LinearAlgebra.jl para funções relacionadas à álgebra linear e cláculo matricial.

Criando Matrizes

Em Julia, a notação tradicional para matrizes utiliza colchetes [ ]. Dentro deles, o espaço ( ) separa as colunas, o ponto e vírgula (;) separa as linhas, e o triplo ponto e vírgula (;;;) adiciona uma nova dimensão, permitindo criar arrays tridimensionais a partir de matrizes bidimensionais.

# Vetor → array 1D (uma dimensão)
v = [1 2 3 4 5 6]
1×6 Matrix{Int64}:
 1  2  3  4  5  6
# Matriz → array 2D (linhas e colunas)
m = [1 2 3; 4 5 6]
2×3 Matrix{Int64}:
 1  2  3
 4  5  6
# Array → array 3D (pilha de matrizes 2D)
M = [1 2 3; 4 5 6; 7 8 9 ;;; 10 11 12; 13 14 15; 16 17 18]
3×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  2  3
 4  5  6
 7  8  9

[:, :, 2] =
 10  11  12
 13  14  15
 16  17  18

Além de escrever manualmente com colchetes, Julia oferece funções que facilitam a criação de matrizes com formatos específicos ou preenchimento automático. Algumas das mais comuns são:

  • zeros(m, n): cria uma matriz \(m \times n\) preenchida com zeros.

  • ones(m, n): gera uma matriz \(m \times n\) preenchida com uns.

  • rand(m, n): cria uma matriz \(m \times n\) com valores aleatórios entre 0 e 1.

  • reshape(v, m, n): transforma um vetor v ou matriz existente em uma nova forma \(m \times n\) .

  • Matrix(...): converte estruturas em matriz; por exemplo, Matrix(I, m, m) cria uma matriz identidade \(m \times n\) .

A = zeros(2, 3)
2×3 Matrix{Float64}:
 0.0  0.0  0.0
 0.0  0.0  0.0
B = ones(3, 2)
3×2 Matrix{Float64}:
 1.0  1.0
 1.0  1.0
 1.0  1.0
C = rand(2, 2)
2×2 Matrix{Float64}:
 0.153179  0.75128
 0.5126    0.708151
# Transformando um vetor em uma matriz 2x3
v = 1:6
1:6
D = reshape(v, 2, 3)
2×3 reshape(::UnitRange{Int64}, 2, 3) with eltype Int64:
 1  3  5
 2  4  6
# Matriz identidade 4x4 com elementos inteiros
E = Matrix{Int64}(I, 4, 4)
4×4 Matrix{Int64}:
 1  0  0  0
 0  1  0  0
 0  0  1  0
 0  0  0  1
# Matriz 3x2 criada com expressão compacta (com base em i + j)
F = [i + j for i in 1:3, j in 1:2]
3×2 Matrix{Int64}:
 2  3
 3  4
 4  5

Indexação e Acesso a Elementos

Assim como em R, a indexação em Julia é 1-based, ou seja, a contagem começa a partir de 1 — diferente do Python, que é 0-based.

Para acessar os elementos de uma matriz, usamos a notação matriz[linha, coluna]. Também é possível acessar linhas e colunas inteiras ou selecionar subconjuntos da matriz utilizando o operador de dois-pontos (:), que indica “todos os elementos” naquela dimensão.

# Cria uma matriz 3x3 com valores de 1 a 9
m1 = reshape(1:9, 3, 3)
3×3 reshape(::UnitRange{Int64}, 3, 3) with eltype Int64:
 1  4  7
 2  5  8
 3  6  9
# Acessa o elemento da 1ª linha, 2ª coluna 
m1[1, 2]
4
# Acessa o elemento da 3ª linha, 3ª coluna 
m1[3, 3]
9
# Acessa toda a 2ª linha 
m1[2, :]
3-element Vector{Int64}:
 2
 5
 8
# Acessa toda a 1ª coluna 
m1[:, 1]
3-element Vector{Int64}:
 1
 2
 3
# Acessa um bloco 2x2 
m1[1:2, 2:3]
2×2 Matrix{Int64}:
 4  7
 5  8

Operações

Julia possibilita a execução de operações matriciais de forma simples e direta.

Adição e Subtração

G = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4
H = [5 6; 7 8]
2×2 Matrix{Int64}:
 5  6
 7  8
G + H  
2×2 Matrix{Int64}:
  6   8
 10  12
G - H  
2×2 Matrix{Int64}:
 -4  -4
 -4  -4

Multiplicação

Existem dois tipos de multiplicação em Julia:

  • *: Multiplicação matricial.

  • .*: Multiplicação elemento a elemento.

G * H
2×2 Matrix{Int64}:
 19  22
 43  50
G * 2
2×2 Matrix{Int64}:
 2  4
 6  8
G .* H
2×2 Matrix{Int64}:
  5  12
 21  32

Transposição

Calcular a transposta de uma matriz com Julia pode ser feito de duas formas: utilizando transpose() ou utilizando o operador '. Contudo, no caso da matriz conter números complexos, ' calculará a conjugada complexa.

transpose(G)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 1  3
 2  4
G'
2×2 adjoint(::Matrix{Int64}) with eltype Int64:
 1  3
 2  4

Propriedades e Funções Úteis

Usando o pacote LinearAlgebra.jl, que já faz parte da instalação padrão do Julia, podemos acessar diversas propriedades e aplicar funções úteis às matrizes. Antes de utilizá-las, é necessário carregar o pacote no ambiente:

using LinearAlgebra

Propriedades Básicas

  • size(m): retorna uma tupla com o número de linhas e colunas.

  • length(m): indica o total de elementos presentes na matriz.

  • eltype(m): retorna o tipo dos elementos da matriz.

  • ndims(m): retorna o número de dimensões (normalmente 2, no caso de matrizes).

# Criando uma matriz 2x2
J = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4
size(J)
(2, 2)
length(J)
4
eltype(J)
Int64
ndims(J)
2

Operações com Álgebra Linear

  • det(m): calcula o determinante da matriz.

  • inv(m): retorna a matriz inversa, se ela existir.

  • rank(m): retorna o posto da matriz (número de linhas/colunas linearmente independentes).

  • eigvals(m): obtém os autovalores da matriz.

  • eigvecs(m): obtém os autovetores correspondentes.

  • tr(m): calcula o traço da matriz (soma dos elementos da diagonal principal).

# Criando uma matriz 2x2
J = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4
det(J)
-2.0
inv(J)
2×2 Matrix{Float64}:
 -2.0   1.0
  1.5  -0.5
rank(J)
2
eigvals(J)
2-element Vector{Float64}:
 -0.3722813232690143
  5.372281323269014
eigvecs(J)
2×2 Matrix{Float64}:
 -0.824565  -0.415974
  0.565767  -0.909377
tr(J)
5

Conclusão

Este foi um guia básico sobre o uso de matrizes em Julia, abordando desde a criação até operações fundamentais e funções úteis com o pacote LinearAlgebra.jl. Por serem estruturas essenciais em inúmeras áreas científicas e computacionais, Julia oferece ferramentas poderosas e eficientes para manipular matrizes de forma intuitiva.

Nos próximos posts, exploraremos tópicos mais avançados, como sistemas lineares, decomposições matriciais e aplicações de matrizes em Machine Learning. Até lá!

Nota

Ferramentas de IA foram utilizadas para correção ortográfica e aprimoramento do texto.