**Referência: Álgebra Linear com aplicações / Anton Howard e Chris Rorres; trad. Claus Ivo Doering. - 8. ed. - Porto Alegre: Bookman, 2001.**¶
Reflexões¶
Considere o operador $T: R^{n}$ → $R^{n}$ que aplica cada vetor na sua imagem simétrica em relação a diferentes eixos. Para conseguir fazer esse processo, vamos utilizar a ideia de Transformação Linear para mudar o vetor de uma base para outra, utilizando nossas matrizes de transformações lineares definidas abaixo.
| Operador | Equações | Matriz Canônica |
| Reflexão em torno do eixo y | $$w_{1} = -x$$ $$w_{2} = y$$ | $\begin{bmatrix} -1 & 0 \\ 0 & 1 \\ \end{bmatrix}$ |
| Reflexão em torno do eixo x | $$w_{1} = x$$ $$w_{2} = -y$$ | $\begin{bmatrix} 1 & 0 \\ 0 & -1 \\ \end{bmatrix} $ |
| Reflexão em torno da reta y = x | $$w_{1} = y$$ $$w_{2} = x$$ | $\begin{bmatrix} 0 & 1 \\ 1 & 0 \\ \end{bmatrix}$ |
Primeiramente, vamos importar as bibliotecas do Python que serão necessárias ao decorrer do progama:
In [1]:
# importando a biblioteca numpy do Python
import numpy as np
# importando a biblioteca matplotlib do Python
from mpl_toolkits import mplot3d
import matplotlib.pyplot as plt
%matplotlib inline
Vamos agora definir uma função que, ao receber um vetor em uma lista e a matriz de transformação adequada, realiza a transformação linear responsável por fazer a reflexão do vetor em questão.
In [2]:
def transformacaoLinear2d(vetor, matriz):
# definindo as dimensões da figura
plt.figure(figsize = (10,5))
# plotando mais de um gráfico na mesma área de trabalho
# plt.subplot(1 linha, 2 colunas, 1º gráfico)
plt.subplot(1,2,1)
# plota o ponto definido para o vetor, esse que parte da origem
plt.scatter(vetor[0], vetor[1], color = "red", label = "(x,y)")
# definindo uma lista mais precisa no eixo x para plotar o vetor
x = [0, vetor[0]]
# definindo uma lista mais precisa no eixo y para plotar o vetor
y = [0, vetor[1]]
# plotando o vetor informado
plt.plot(x, y, color = "blue", label = "x")
# adicionando uma grade ao gráfico
plt.grid(True)
# removendo a moldura do gráfico
plt.box(False)
# adicionando a legenda ao gráfico
plt.legend()
# adicionando um título ao gráfico
plt.title("Antes da Transformação")
# realizando a mudança de base para o vetor com a matriz de transformação linear
novoVetor = np.dot(vetor, matriz)
# plotando mais de um gráfico na mesma área de trabalho
# plt.subplot(1 linha, 2 colunas, 2º gráfico)
plt.subplot(1,2,2)
# plota o ponto definido para o vetor, esse que parte da origem
plt.scatter(vetor[0], vetor[1], color = "red", label = "(x,y)")
# plotando o vetor informado
plt.plot(x, y, color = "blue", label = "x")
# definindo uma lista mais precisa no eixo x para plotar o novo vetor
x = [0, novoVetor[0]]
# definindo uma lista mais precisa no eixo y para plotar o novo vetor
y = [0, novoVetor[1]]
# plota o ponto definido para o vetor, esse que parte da origem
plt.scatter(x, y, color = "yellow", label = "(T(x1),T(y1))")
# plotando o vetor obtido
plt.plot(x, y, color = "brown", label = "w = T(x)")
# adicionando uma grade ao gráfico
plt.grid(True)
# removendo a moldura do gráfico
plt.box(False)
# adicionando a legenda ao gráfico
plt.legend()
# adicionando um título ao gráfico
plt.title("Após a Transformação")
# função não retorna nenhum valor
return None
Vamos agora definir um vetor qualquer, para testarmos as matrizes de transformação.
In [3]:
# definindo um vetor qualquer para utilizarmos no nosso exemplo
vetor2d = [3,4]
Por fim, devemos definir as matrizes também em Python para conseguirmos compilar e visualizar as transformações lineares com auxílio da função acima.
In [4]:
# definindo a matriz de reflexão em torno do eixo y
matriz1 = np.array([[-1, 0],
[0, 1]])
# definindo a matriz de reflexão em torno do eixo x
matriz2 = np.array([[1, 0],
[0, -1]])
# definindo a matriz de reflexão em torno da reta y = x
matriz3 = np.array([[0, 1],
[1, 0]])
Agora que definimos todo o nosso ambiente de trabalho para realizar as diferentes reflexões em nosso vetor, podemos visualizar o comportamento gráfico das transformações lineares:
Reflexão em torno do eixo y¶
In [5]:
# realizando a transformação linear responsável por fazer uma reflexão em torno do eixo y
transformacaoLinear2d(vetor2d, matriz1)
In [6]:
# visualizando o vetor antes da transformação linear
print(vetor2d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor2d, matriz1))
[3, 4] [-3 4]
Reflexão em torno do eixo x¶
In [7]:
# realizando a transformação linear responsável por fazer uma reflexão em torno do eixo x
transformacaoLinear2d(vetor2d, matriz2)
In [8]:
# visualizando o vetor antes da transformação linear
print(vetor2d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor2d, matriz2))
[3, 4] [ 3 -4]
Reflexão em torno da reta y = x¶
In [9]:
# realizando a transformação linear responsável por fazer uma reflexão em torno da reta y = x
transformacaoLinear2d(vetor2d, matriz3)
In [10]:
# visualizando o vetor antes da transformação linear
print(vetor2d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor2d, matriz3))
[3, 4] [4 3]
podemos definir as mesmas transformações lineares usando 3 dimensões. Observe as semelhanças com o processo anterior na nova função abaixo.
In [11]:
def transformacaoLinear3d(vetor, matriz):
# definindo as dimensões da figura
fig = plt.figure(figsize = (20,10))
# definindo o ambiente 3d para a plotagem
ax = plt.axes(projection="3d")
# plotando mais de um gráfico na mesma área de trabalho
# plt.subplot(1 linha, 2 colunas, 1º gráfico)
ax = fig.add_subplot(1, 2, 1, projection='3d')
# plota o ponto definido para o vetor, esse que parte da origem
ax.scatter3D(vetor[0], vetor[1], vetor[2], color = "red", label = "(x,y,z)")
# definindo uma lista mais precisa no eixo x para plotar o vetor
x = [0, vetor[0]]
# definindo uma lista mais precisa no eixo y para plotar o vetor
y = [0, vetor[1]]
# definindo uma lista mais precisa no eixo z para plotar o vetor
z = [0, vetor[2]]
# plotando o vetor informado
ax.plot3D(x, y, z, color = "blue", label = "x")
ax.plot3D([0,1], [0,0], [0,0], color = "green")
ax.plot3D([0,0], [0,1], [0,0], color = "green")
ax.plot3D([0,0], [0,0], [0,1], color = "green")
# adicionando uma grade ao gráfico
plt.grid(True)
# removendo a moldura do gráfico
plt.box(False)
# adicionando a legenda ao gráfico
plt.legend()
# adicionando um título ao gráfico
plt.title("Antes da Transformação")
# realizando a mudança de base para o vetor com a matriz de transformação linear
novoVetor = np.dot(vetor, matriz)
# plotando mais de um gráfico na mesma área de trabalho
# plt.subplot(1 linha, 2 colunas, 2º gráfico)
ax = fig.add_subplot(1, 2, 2, projection='3d')
# plota o ponto definido para o vetor, esse que parte da origem
ax.scatter3D(vetor[0], vetor[1], vetor[2], color = "red", label = "(x,y,z)")
# plotando o vetor informado
ax.plot3D(x, y, z, color = "blue", label = "x")
# definindo uma lista mais precisa no eixo x para plotar o novo vetor
x = [0, novoVetor[0]]
# definindo uma lista mais precisa no eixo y para plotar o novo vetor
y = [0, novoVetor[1]]
# definindo uma lista mais precisa no eixo z para plotar o novo vetor
y = [0, novoVetor[2]]
# plota o ponto definido para o vetor, esse que parte da origem
ax.scatter3D(x, y, z, color = "yellow", label = "(T(x1),T(y1), T(z1))")
# plotando o vetor obtido
ax.plot3D(x, y, z, color = "brown", label = "w = T(x)")
ax.plot3D([0,1], [0,0], [0,0], color = "green")
ax.plot3D([0,0], [0,1], [0,0], color = "green")
ax.plot3D([0,0], [0,0], [0,1], color = "green")
# adicionando uma grade ao gráfico
plt.grid(True)
# removendo a moldura do gráfico
plt.box(False)
# adicionando a legenda ao gráfico
plt.legend()
# adicionando um título ao gráfico
plt.title("Após a Transformação")
# função não retorna nenhum valor
# função não retorna nenhum valor
return None
As matrizes de transformação que serão utilizadas para realizar a reflexão do vetor em 3 dimensões em torno do plano xy, plano xz e plano yz, respectivamente, estão ilustradas abaixo:
| Operador | Equações | Matriz Canônica |
| Reflexão em torno do plano xy | $$w_{1} = x$$ $$w_{2} = y$$ $$w_{3} = -z$$ | $\begin{bmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 1 & -1 \\ \end{bmatrix}$ |
| Reflexão em torno do plano xz | $$w_{1} = x$$ $$w_{2} = -y$$ $$w_{3} = z$$ | $\begin{bmatrix} 1 & 0 & 0 \\ 0 & -1 & 0 \\ 0 & 1 & 1 \\ \end{bmatrix}$ |
| Reflexão em torno do plano yz | $$w_{1} = -x$$ $$w_{2} = y$$ $$w_{3} = z$$ | $\begin{bmatrix} -1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 1 & 1 \\ \end{bmatrix}$ |
Devemos agora definir um vetor em 3 dimensões e tornar as matrizes acima compiláveis pelo Python:
In [12]:
# definindo um vetor qualquer para utilizarmos no nosso exemplo
vetor3d = [1,2,3]
In [13]:
# definindo a matriz de reflexão em torno do plano xy
matriz4 = np.array([[1, 0, 0],
[0, 1, 0],
[0, 0, -1]])
# definindo a matriz de reflexão em torno do plano xz
matriz5 = np.array([[1, 0, 0],
[0, -1, 0],
[0, 0, 1]])
# definindo a matriz de reflexão em torno do plano yz
matriz6 = np.array([[-1, 0, 0],
[0, 1, 0],
[0, 0, 1]])
Agora que definimos todo o ambiente de trabalho para realizar as reflexões no vetor, podemos visualizar o compartamento gráfico das transformações lineares:
Reflexão em torno do plano xy¶
In [14]:
# realizando a transformação linear responsável por fazer uma reflexão em torno do plano xy
transformacaoLinear3d(vetor3d, matriz4)
In [15]:
# visualizando o vetor antes da transformação linear
print(vetor3d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor3d, matriz4))
[1, 2, 3] [ 1 2 -3]
Reflexão em torno do plano xz¶
In [16]:
# realizando a transformação linear responsável por fazer uma reflexão em torno do plano xz
transformacaoLinear3d(vetor3d, matriz5)
In [17]:
# visualizando o vetor antes da transformação linear
print(vetor3d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor3d, matriz5))
[1, 2, 3] [ 1 -2 3]
Reflexão em torno do plano yz¶
In [18]:
# realizando a transformação linear responsável por fazer uma reflexão em torno do plano yz
transformacaoLinear3d(vetor3d, matriz6)
In [19]:
# visualizando o vetor antes da transformação linear
print(vetor3d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor3d, matriz6))
[1, 2, 3] [-1 2 3]
Projeções¶
Considere o operador $T: R^{n}$ → $R^{n}$ que leva cada vetor na sua projeção ortogonal sobre os eixos.
| Operador | Equações | Matriz Canônica |
| Projeção ortogonal sobre o eixo x | $$w_{1} = x$$ $$w_{2} = 0$$ | $\begin{bmatrix} 1 & 0 \\ 0 & 0 \\ \end{bmatrix}$ |
| Projeção ortogonal sobre o eixo y | $$w_{1} = 0$$ $$w_{2} = y$$ | $\begin{bmatrix} 0 & 0 \\ 0 & 1 \\ \end{bmatrix}$ |
Devemos agora definir as matrizes acima compiláveis pelo Python:
In [20]:
# definindo a matriz de transformação para a projeção ortogonal sobre o eixo x
matriz7 = np.array([[1, 0],
[0, 0]])
# definindo a matriz de transformação para a projeção ortogonal sobre o eixo y
matriz8 = np.array([[0, 0],
[0, 1]])
Projeção ortogonal no eixo x¶
In [21]:
# realizando a transformação linear responsável por fazer uma projeção ortogonal no eixo x
transformacaoLinear2d(vetor2d, matriz7)
In [22]:
# visualizando o vetor antes da transformação linear
print(vetor2d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor2d, matriz7))
[3, 4] [3 0]
Projeção ortogonal no eixo y¶
In [23]:
# realizando a transformação linear responsável por fazer uma projeção ortogonal no eixo y
transformacaoLinear2d(vetor2d, matriz8)
In [24]:
# visualizando o vetor antes da transformação linear
print(vetor2d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor2d, matriz8))
[3, 4] [0 4]
As matrizes de transformação que serão utilizadas para realizar a projeção ortogonal do vetor em 3 dimensões em torno do plano xy, plano xz e plano yz, respectivamente, estão ilustrados abaixo:
| Operador | Equações | Matriz Canônica |
| Projeção ortogonal sobre o plano xy | $$w_{1} = x$$ $$w_{2} = y$$ $$w_{3} = 0$$ | $\begin{bmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 0 \\ \end{bmatrix}$ |
| Projeção ortogonal sobre o plano xz | $$w_{1} = x$$ $$w_{2} = 0$$ $$w_{3} = z$$ | $\begin{bmatrix} 1 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 1 \\ \end{bmatrix}$ |
| Projeção ortogonal sobre o plano yz | $$w_{1} = 0$$ $$w_{2} = y$$ $$w_{3} = z$$ | $\begin{bmatrix} 0 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \\ \end{bmatrix}$ |
Devemos agora definir as matrizes acima compiláveis pelo Python:
In [25]:
# definindo a matriz de transformação para a projeção ortogonal sobre o plano xy
matriz9 = np.array([[1, 0, 0],
[0, 1, 0],
[0, 0, 0]])
# definindo a matriz de transformação para a projeção ortogonal sobre o plano xz
matriz10 = np.array([[1, 0, 0],
[0, 0, 0],
[0, 0, 1]])
# definindo a matriz de transformação para a projeção ortogonal sobre o plano yz
matriz11 = np.array([[0, 0, 0],
[0, 1, 0],
[0, 0, 1]])
Projeção ortogonal sobre o plano xy¶
In [26]:
# realizando a transformação linear responsável por fazer uma projeção ortogonal sobre o plano xy
transformacaoLinear3d(vetor3d, matriz9)
In [27]:
# visualizando o vetor antes da transformação linear
print(vetor3d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor3d, matriz9))
[1, 2, 3] [1 2 0]
Projeção ortogonal sobre o plano xz¶
In [28]:
# realizando a transformação linear responsável por fazer uma projeção ortogonal sobre o plano xz
transformacaoLinear3d(vetor3d, matriz10)
In [29]:
# visualizando o vetor antes da transformação linear
print(vetor3d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor3d, matriz10))
[1, 2, 3] [1 0 3]
Projeção ortogonal sobre o plano yz¶
In [30]:
# realizando a transformação linear responsável por fazer uma projeção ortogonal sobre o plano yz
transformacaoLinear3d(vetor3d, matriz11)
In [31]:
# visualizando o vetor antes da transformação linear
print(vetor3d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor3d, matriz11))
[1, 2, 3] [0 2 3]
Rotações¶
Um operador que gira cada vetor em $R^{n}$ por um ângulo fixado θ é chamado uma rotação em $R^{n}$.
| Operador | Equações | Matriz Canônica |
| Rotação pelo ângulo θ | $$w_{1} = x.cos(t) + y.sen(t)$$ $$w_{2} = -x.sen(t) + y.cos(t)$$ | $\begin{bmatrix} cos(t) & sen(t) \\ -sen(t) & cos(t) \\ \end{bmatrix}$ |
Devemos agora definir um ângulo qualquer (vamos usar 45°) e tornar as matrizes acima compiláveis pelo Python:
In [32]:
# definindo um ângulo de 45° para utilizarmos no nosso exemplo, em radianos
teta = np.pi / 4
In [33]:
# definindo a matriz de transformação para a rotação dado um ângulo qualquer
matriz12 = np.array([[np.cos(teta), (np.sin(teta))],
[-np.sin(teta), np.cos(teta)]])
Rotação de um vetor 45º¶
In [34]:
# realizando a transformação linear responsável por fazer uma rotação dado um ângulo teta
transformacaoLinear2d(vetor2d, matriz12)
In [35]:
# visualizando o vetor antes da transformação linear
print(vetor2d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor2d, matriz12))
[3, 4] [-0.70710678 4.94974747]
Vamos mudar o ângulo θ para 90°:
In [36]:
# definindo um ângulo de 90º para teta, em radianos
teta = np.pi / 2
In [37]:
# definindo a matriz de transformação para a rotação dado um ângulo qualquer
matriz12 = np.array([[np.cos(teta), (np.sin(teta))],
[-np.sin(teta), np.cos(teta)]])
Rotação de um vetor 90º¶
In [38]:
# realizando a transformação linear responsável por fazer uma rotação dado um ângulo teta
transformacaoLinear2d(vetor2d, matriz12)
In [39]:
# visualizando o vetor antes da transformação linear
print(vetor2d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor2d, matriz12))
[3, 4] [-4. 3.]
As matrizes de transformação que serão utilizadas para realizar as rotações do vetor em 3 dimensões estão ilustradas abaixo:
| Operador | Equações | Matriz Canônica |
| Rotação anti-horária em torno do eixo x positivo por um ângulo θ | $$w_{1} = x$$ $$w_{2} = y.cos(t) - z.sen(t)$$ $$w_{3} = y.sen(t) + z.cos(t)$$ | $\begin{bmatrix} 1 & 0 & 0 \\ 0 & cos(t) & -sen(t) \\ 0 & sen(t) & cos(t) \\ \end{bmatrix}$ |
| Rotação anti-horária em torno do eixo y positivo por um ângulo θ | $$w_{1} = x.cos(t) + z.sen(t)$$ $$w_{2} = y$$ $$w_{3} = -x.sen(t) + z.cos(t)$$ | $\begin{bmatrix} cos(t) & 0 & sen(t) \\ 0 & 1 & 0 \\ -sen(t) & 0 & cos(t) \\ \end{bmatrix}$ |
| Rotação anti-horária em torno do eixo z positivo por um ângulo θ | $$w_{1} = x.cos(t) - y.sen(t)$$ $$w_{2} = x.sen(t) + y.cos(t)$$ $$w_{3} = z$$ | $\begin{bmatrix} cos(t) & -sen(t) & 0 \\ sen(t) & cos(t) & 0 \\ 0 & 0 & 1 \\ \end{bmatrix}$ |
Devemos agora definir as matrizes acima compiláveis pelo Python:
In [40]:
# definindo um ângulo de 30º para utilizarmos no nosso exemplo
teta = np.pi / 6
In [41]:
# definindo a matriz de transformação para rotação anti-horária em torno do eixo x positivo por um ângulo
# teta
matriz13 = np.array([[1, 0, 0],
[0, np.cos(teta), -np.sin(teta)],
[0, np.sin(teta), np.cos(teta)]])
# definindo a matriz de transformação para rotação anti-horária em torno do eixo y positivo por um ângulo
# teta
matriz14 = np.array([[np.cos(teta), 0, np.sin(teta)],
[0, 1, 0],
[-np.sin(teta), 0, np.cos(teta)]])
# definindo a matriz de transformação para rotação anti-horária em torno do eixo z positivo por um ângulo
# teta
matriz15 = np.array([[np.cos(teta), -np.sin(teta), 0],
[np.sin(teta), np.cos(teta), 0],
[0, 0, 1]])
rotação anti-horária em torno do eixo x positivo por um ângulo 30º¶
In [42]:
# realizando a transformação linear responsável por fazer uma rotação anti-horária em
# torno do eixo x positivo por um ângulo θ
transformacaoLinear3d(vetor3d, matriz13)
In [43]:
# visualizando o vetor antes da transformação linear
print(vetor3d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor3d, matriz13))
[1, 2, 3] [1. 3.23205081 1.59807621]
rotação anti-horária em torno do eixo y positivo por um ângulo 30°¶
In [44]:
# realizando a transformação linear responsável por fazer uma rotação anti-horária em
# torno do eixo y positivo por um ângulo θ
transformacaoLinear3d(vetor3d, matriz14)
In [45]:
# visualizando o vetor antes da transformação linear
print(vetor3d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor3d, matriz14))
[1, 2, 3] [-0.6339746 2. 3.09807621]
rotação anti-horária em torno do eixo z positivo por um ângulo 30º¶
In [46]:
# realizando a transformação linear responsável por fazer uma rotação anti-horária em
# torno do eixo z positivo por um ângulo θ
transformacaoLinear3d(vetor3d, matriz15)
In [47]:
# visualizando o vetor antes da transformação linear
print(vetor3d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor3d, matriz15))
[1, 2, 3] [1.8660254 1.23205081 3. ]
Dilatações e Contrações¶
Se k é um escalar não-negativo, então o operador $T(x) = kx$ de $R^{n}$ é chamado uma homotetia de razão k; especificamente, o operador é uma contração de razão k se 0 ≤ k ≤ 1 e uma dilatação de razão k se k ≥ 1. O efeito geométrico de uma contração é comprimir cada vetor por um fator k e o efeito geométrico de uma dilatação é esticar cada vetor por um fator k. Uma contração comprime $R^{n}$ uniformemente de todas as direções na direção da origem e uma dilatação expande $R^{n}$ uniformemente em todas as direções para longe da origem. A contração mais extrema ocorre quando k = 0, caso em que $T(x) = kx$ reduz ao operador nulo $T(x) = 0$, que comprime cada vetor a um único ponto (a origem). Se k = 1, então $T(x) = kx$ reduz ao operador identidade $T(x) = x$, que deixa cada vetor inalterado; isto poderia ser considerado tanto uma contração quanto uma dilatação.
| Operador | Equações | Matriz Canônica |
| Contração de fator k em $R^{2}$ (0 ≤ k ≤ 1) | $$w_{1} = kx$$ $$w_{2} = ky$$ | $\begin{bmatrix} k & 0 \\ 0 & k \\ \end{bmatrix}$ |
| Dilatação de fator k em $R^{2}$ (0 ≥ 1) | $$w_{1} = kx$$ $$w_{2} = ky$$ |
Devemos agora defininir um valor para k, e tornar as matrizes acima compiláveis pelo Python:
In [48]:
# definindo um valor para k de contração
k = 0.75
In [49]:
# definindo a matriz de transformação para dilatações e contrações de vetores
matriz16 = np.array([[k, 0],
[0, k]])
Contração de um vetor quando k = 0.75¶
In [50]:
# realizando a transformação linear responsável por fazer uma contração no vetor
transformacaoLinear2d(vetor2d, matriz16)
In [51]:
# visualizando o vetor antes da transformação linear
print(vetor2d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor2d, matriz16))
[3, 4] [2.25 3. ]
In [52]:
# definindo um vetor qualquer para utilizarmos no nosso exemplo
vetor = [2,2]
# definindo um valor para k de dilatação
k = 2
In [53]:
# definindo a matriz de transformação para dilatações e contrações de vetores
matriz16 = np.array([[k, 0],
[0, k]])
Dilatação de um vetor quando k = 2¶
In [54]:
# realizando a transformação linear responsável por fazer uma dilatação no vetor
transformacaoLinear2d(vetor2d, matriz16)
In [55]:
# visualizando o vetor antes da transformação linear
print(vetor2d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor2d, matriz16))
[3, 4] [6 8]
As matrizes de transformação que serão utilizadas para realizar as contrações e dilatações do nosso vetor em 3 dimensões estão ilustradas abaixo:
| Operador | Equações | Matriz Canônica |
| Contração de fator k em $R^{3}$ (0 ≤ k ≤ 1) | $$w_{1} = kx$$ $$w_{2} = ky$$ $$w_{3} = kz$$ | $\begin{bmatrix} k & 0 & 0 \\ 0 & k & 0 \\ 0 & 0 & k \\ \end{bmatrix}$ |
| Dilatação de fator k em $R^{3}$ (k ≥ 1) | $$w_{1} = kx$$ $$w_{2} = ky$$ $$w_{3} = kz$$ |
Devemos agora tornar as matrizes acima compiláveis pelo Python:
In [56]:
# definindo um valor de contração para k
k = 0.25
In [57]:
# definindo a matriz de transformação para dilatações e contrações de vetores
matriz17 = np.array([[k, 0, 0],
[0, k, 0],
[0, 0, k]])
Contração de um vetor quando k = 0.25¶
In [58]:
# realizando a transformação linear responsável por fazer uma contração no vetor
transformacaoLinear3d(vetor3d, matriz17)
In [59]:
# visualizando o vetor antes da transformação linear
print(vetor3d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor3d, matriz17))
[1, 2, 3] [0.25 0.5 0.75]
In [60]:
# definindo um vetor qualquer para utilizarmos no nosso exemplo
vetor = [2,2,2]
# definindo um valor de dilatação para k
k = 2
In [61]:
# definindo a matriz de transformação para dilatações e contrações de vetores
matriz17 = np.array([[k, 0, 0],
[0, k, 0],
[0, 0, k]])
Dilatação de um vetor quando k = 2¶
In [62]:
# realizando a transformação linear responsável por fazer uma contração no vetor
transformacaoLinear3d(vetor3d, matriz17)
In [63]:
# visualizando o vetor antes da transformação linear
print(vetor3d)
# visualizando o vetor depois da transformação linear
print(np.dot(vetor3d, matriz17))
[1, 2, 3] [2 4 6]