Transformações Lineares¶

Em Matemática, uma transformação linear é um tipo particular de função entre dois espaços vetoriais que preserva as operações de adição vetorial e multiplicação por escalar. Uma transformação linear também pode ser chamada de aplicação linear ou mapa linear.¶

Definição:¶

Se T: V → W é uma função de um espaço vetorial V em um outro espaço vetorial W, então T é chamada uma transformação linear de V em W se, para quaisquer vetor u e v em V e qualquer escalar c valem

$a) T(u + v) = T(u) + T(v)$
$b) T(cv) = cT(v)$

No caso especial em que V = W, a transformação linear é chamada um operador linear de V.

Importação das Bibliotecas¶

In [1]:

# importando a biblioteca numpy do python
import numpy
# importando a biblioteca matplotlib do python
import matplotlib.pyplot as plt
%matplotlib inline

In [2]:

# importando a biblioteca 'plot_helper'
from plot_helper import *

Vetor Representado em Diferentes Pontos no Plano Cartesiano¶

Vamos agora começar a ver como podemos representar computacionalmente, no Python, vetores em um plano cartesiano.

In [3]:

# definindo um vetor qualquer
vetor = [(2,2)] 
# pontos de origem do vetor acima
origens = [(0,-1), (0,1), (0,0), (0,2)] 
# plota os gráficos do vetor, com seu respectivo módulo, direção, sentido e origem
plot_vector(vetor, origens) 
# título do gráfico
plt.title("Um vetor com diferentes pontos de origem."); 

Soma de Vetores¶

Vamos agora realizar a soma entre dois vetores, dado que teremos um vetor resultante dessa operação.

In [4]:

# soma de vetores

# primeiro vetor
vetorA = numpy.array((4,-2)) 
# segundo vetor
vetorB = numpy.array((-2,6)) 

# uma lista de vetores = vetorA, vetorB e a soma vetorA + vetorB
vetores = [vetorA, vetorB, vetorA + vetorB] 

# plota na tela o grafico dos vetores definidos
plot_vector(vetores) 
# título do gráfico
plt.title("Soma de dois vetores: (4,-2) + (-2,6) = (2,4)"); 

Subtração de Vetores¶

Vamos agora realizar a subtração entre dois vetores, dado que teremos um vetor resultante dessa operação.

In [5]:

# subtração de vetores

# primeiro vetor
vetorA = numpy.array((4,-2)) 
# segundo vetor
vetorB = numpy.array((-2,6)) 

# uma lista de vetores = vetorA, vetorB e a subtração vetorA - vetorB
vetores = [vetorA, vetorB, vetorA - vetorB] 

# plota na tela o grafico dos vetores definidos
plot_vector(vetores) 
# título do gráfico
plt.title("Subtração de dois vetores: (4,-2) - (-2,6) = (6,-8)"); 

Multiplicação de um Vetor por um Escalar¶

Vamos agora realizar a multiplicação de um vetor por um escalar, dado que teremos um vetor resultante dessa operação.

In [6]:

# multiplicação de um vetor por um escalar

# criando um vetor c
vetorC = numpy.array((1,1)) 
# definindo uma lista de vetores, em que o vetorC é multiplicado por escalares
vetores = [vetorC, 2 * vetorC, -2 * vetorC] 
# plota o gráfico dos dois vetores na tela
plot_vector(vetores) 
# título do gráfico
plt.title("Multiplicação do vetor (1,1) por escalares 2 e -2"); 

Base Canônica de um Vetor¶

In [7]:

# bases de um vetor

# definindo a componente i da base
i = numpy.array((1,0)) 
# definindo a componente j da base
j = numpy.array((0,1)) 

#definindo a liste de vetores
vetores = [i, j]

# plota o gráfico dos vetores definidos
plot_vector(vetores) 
# título do gráfico
plt.title("Base Canônica");

Vamos mostrar que através da base canônica podemos representar qualquer vetor possível.

In [8]:

# definindo uma lista de vetores
vetores = [i, j, (4 * i), (3 * j), (4 * i + 3 * j)] 

# plota o gráfico dos vetores definidos
plot_vector(vetores) 

# título do gráfico
plt.title("Combinações feitas com os vetores da base canônica, resultando no vetor (4,3)");

Conjunto de Todas as Combinações Lineares Possíveis Entre Dois Vetores¶

In [9]:

# importa a função da biblioteca Python: randint
from numpy.random import randint 

# conjunto de todas as combinações lineares possíveis entre dois vetores
vetores = [] # lista vazia

# definindo a componente i da base
i = numpy.array((1,0)) 
# definindo a componente j da base
j = numpy.array((0,1)) 

# estrutura de repetição for, 1000 vezes, para o conteúdo abaixo
# nesse caso imprime 1000 vetores possíveis, resultado da combinação linear de outros dois vetores, 
# no intervalo de (0,0) até (-10,10)

for _ in range(1000):
    # escolhe um número aleatório entre -10 e 10
    m = randint(-10,10) 
    # escolhe um número aleatório entre -10 e 10
    n = randint(-10,10) 
    # acrescenta a lista o vetor combinado com a base
    vetores.append(m * i + n * j) 

# a lista incialmente vazia, agora armazena 1000 vetores na mémoria da máquina

# plota o gráfico da lista de vetores definidas
plot_vector(vetores) 
# título do gráfico definido
plt.title("1000 vetores aleatórios criados a partir da base canônica"); 

O mesmo pode ser feito a nível de combinação linear de dois vetores:¶

In [10]:

# primeiro vetor
vetorA = numpy.array((2,-1)) 
# segundo vetor
vetorB = numpy.array((-1,3)) 

# lista vazia
vetores = [] 

#estrutura de repetição for que gera 10 vetores a partir de combinações aleatórias dos vetores a e b, 
# com escalares entre -10 e 10
for _ in range(10):
    # escolhe um número aleatório entre -10 e 10
    escalar1 = randint(-10,10) 
    # escolhe um número aleatório entre -10 e 10
    escalar2 = randint(-10,10) 
    # acrescenta a lista o vetor combinado com a base
    vetores.append(escalar1 * vetorA + escalar2 * vetorB) 
    
# a lista incialmente vazia, agora armazena 10 vetores na mémoria da máquina

# plota o gráfico da lista de vetores definidas
plot_vector(vetores) 

# título do gráfico definido
plt.title("10 combinações lineares entre o vetor (2,-1) e (-1,3), com escalares aleatórios"); 

Podemos ter um vetor colinear, em que tendo 3 ou mais pontos, podemos traçar uma reta sobre ele

In [11]:

# primeiro vetor
vetorA = numpy.array((2,-1)) 
# segundo vetor: A * -2, para se colinear
vetorD = numpy.array((-4,2)) 

vetores = [] # lista vazia

# estrutura de repetição for que gera 10 vetores aleatórios,com multiplicação por escalares entre (-10,10)
for _ in range(10):
    # escolhe um número aleatório entre -10 e 10
    escalar1 = randint(-10,10) 
    # escolhe um número aleatório entre -10 e 10
    escalar2 = randint(-10,10) 
    # adiciona a lista um vetor combinado da base
    vetores.append(escalar1 * vetorA + escalar2 * vetorD) 
    
# a lista incialmente vazia, agora armazena 10 vetores na mémoria da máq

# plota o gráfico da lista de vetores definidos
plot_vector(vetores) 

# título do gráfico
plt.title("10 combinações lineares entre os vetores (2,-1) e -2(2,-1), com escalares aleatórios"); 

Transformações Lineares¶

Vamos usar uma matriz de transformação linear $$\begin{bmatrix} -2 & 1 \\ 1 & -3 \\ \end{bmatrix}$$ a partir da base canônica.

In [12]:

# vamos fazer uma transformação linear
# temos a base usual do plano cartesiano x * (1,0) + y * (0,1)

# definimos uma matriz de transformação linear
baseA = numpy.array([(-2,1),(1,-3)]) 

# agora temos uma nova base fruto da transformação linear
plot_linear_transformation(baseA) 
# x * (-2,1) + y * (1,-3)

Aplicando uma Transformação Linear em um Vetor¶

Vamos usar uma matriz de transformação linear

$\begin{bmatrix} 1 & 2 \\ 2 & 1 \\ \end{bmatrix}$

a partir da base canônica. Vamos usar o vetor (1,2).

In [13]:

# vamos fazer uma transformação linear (exemplo 1)
# temos a base usual do plano cartesiano x * (1,0) + y * (0,1)

# definimos uma matriz de transformação linear
baseM = numpy.array([(1,2),(2,1)]) 

# definimos um vetor
vetorX = numpy.array((1,2)) 

# definimos o vetor em duas situações: na base canônica e após a mudança de base
vetores = [vetorX, baseM.dot(vetorX)] # lista de vetores
# o segundo vetor da lista trata da multiplicação do vetorX pela nova matriz 

# plotar o gráfico da lista de vetores
plot_vector(vetores) 

# título do gráfico
plt.title("Aplicando uma Transformação Linear em um Vetor")

Out[13]:

Text(0.5, 1.0, 'Aplicando uma Transformação Linear em um Vetor')

Observe que o vetor foi dilatado. Vamos usar um outro vetor para ver se a dilatação fica mais clara de se analisar.

In [14]:

# vamos fazer uma transformação linear (exemplo 2)
# temos a base usual do plano cartesiano x * (1,0) + y * (0,1)

# definimos uma matriz 
baseM = numpy.array([(1,2),(2,1)]) 
# definimos um vetor
vetorX = numpy.array((1,1)) 

# definimos o vetor em duas situações: na base canônica e após a mudança de base

# lista de vetores
vetores = [vetorX, baseM.dot(vetorX)] 
 # plotar o gráfico da lista de vetores
plot_vector(vetores)

# título do gráfico
plt.title("Aplicando uma Transformação Linear em um Vetor")

Out[14]:

Text(0.5, 1.0, 'Aplicando uma Transformação Linear em um Vetor')

Rotação¶

Vamos definir uma matriz de transformação linear responsável por rotacionar os vetores, mudando os seus sentidos.

Vamos usar uma matriz de transformação linear

$\begin{bmatrix} 0 & -1 \\ 1 & 0 \\ \end{bmatrix}$

a partir da base canônica.

In [15]:

# definindo uma matriz de tranformação linear que rotaciona vetores
rotacao = numpy.array([[0,-1], [1,0]]) 

In [16]:

# plotando o gráfico da transformação linear de rotação
plot_linear_transformation(rotacao) 

In [17]:

# definimos um vetor
vetorX = numpy.array((1,2)) 

# definimos o vetor em duas situações: na base canônica e após sofrer a rotação

# lista de vetores
vetores = [vetorX, rotacao.dot(vetorX)] 
# aplicando a rotação no vetorX

# plotar o gráfico da lista de vetores
plot_vector(vetores) 

# título do gráfico
plt.title("Aplicando uma Transformação Linear em um Vetor")

Out[17]:

Text(0.5, 1.0, 'Aplicando uma Transformação Linear em um Vetor')

Mudança de escala¶

Podemos também usar uma transformação linear responsável por contrair um eixo e expandir outro, por exemplo.

Vamos usar uma matriz de transformação linear

$\begin{bmatrix} 2 & 0 \\ 0 & \frac{1}{2} \\ \end{bmatrix}$

a partir da base canônica.

In [18]:

# matriz de transformação que dobra o eixo x e diminui pela metade o eixo y
escala = numpy.array([[2,0], [0,0.5]]) 

# plotando o gráfico da nova base após a transformação linear
plot_linear_transformation(escala) 

In [19]:

# definimos um vetor
vetorX = numpy.array((1,1)) 

# definimos o vetor em duas situações: na base canônica e após a mudança de escala

# lista de vetores
vetores = [vetorX, escala.dot(vetorX)] 
# mundando a escala do vetor

# plotar o gráfico da lista de vetores
plot_vector(vetores) 

# título do gráfico
plt.title("Aplicando uma Transformação Linear em um Vetor")

Out[19]:

Text(0.5, 1.0, 'Aplicando uma Transformação Linear em um Vetor')

Aplicando Transformações Lineares Consecutivas¶

In [20]:

base = numpy.array([[0,1],[-1,0]]) # definindo uma matriz de transformação para a base canônica

# a ordem de transformação é da direita para a esquerda
plot_linear_transformations(rotacao, base) 
# plota os gráficos das duas transformações lineares na base de forma consecutiva

Matriz Inversa¶

Acima foi usado uma matriz de trasformação que, após a base ter sido transformada pela matriz de rotação, ela a trasnformou novamente para a base canônica. Vamos usar a ideia de matriz inversa para fazer o meso processo.

Vamos usar uma matriz de transformação linear

$\begin{bmatrix} 1 & 2 \\ 2 & 1 \\ \end{bmatrix}$

a partir da base canônica.

In [21]:

# importando a função da biblioteca numpy, do conjunto de funções linalg: inv
from numpy.linalg import inv 

In [22]:

baseM = numpy.array([(1,2),(2,1)]) # definimos uma matriz de transformação linear

M_inversa = inv(baseM) # define uma matriz inversa 

# a ordem de transformação é da direita para a esquerda

# plota os gráficos das duas transformações lineares na base de forma consecutiva
plot_linear_transformations(baseM, M_inversa) 

Funções definidas por L. Barba e T. Wang para uma apresentação no evento SciPy 2019:¶

plot_vector, plot_linear_transformation e plot_linear_transformations¶¶

Alguma Dúvida? Entre em Contato Comigo:¶

Me envie um e-mail;