#!/usr/bin/env python
# coding: utf-8

# # A Geometria das Transformações Lineares
# #### Dependendo de como encaramos uma n-upla, se como um ponto ou um vetor, o efeito geométrico de um operador $T: R^{n}$ → $R^{n}$ é o de transformar cada ponto (ou vetor) de $R^{n}$ em algum novo ponto (ou vetor).

# ##### ****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.

# <table>
#     <tr>
#         <td><b> Operador </b></td>
#         <td><b> Equações </b></td>
#         <td><b> Matriz Canônica </b></td>
#     <tr>
#         <td> Reflexão em torno do <b>eixo y</b> </td>
#         <td> $$w_{1} = -x$$ $$w_{2} = y$$ </td>
#         <td> $\begin{bmatrix}
#                       -1 & 0 \\
#                        0 & 1 \\
#                       \end{bmatrix}$ </td>
#     <tr>
#         <td> Reflexão em torno do <b>eixo x</b> </td>
#         <td> $$w_{1} = x$$ $$w_{2} = -y$$ </td>
#         <td> $\begin{bmatrix}
#                       1 & 0 \\
#                       0 & -1 \\
#                       \end{bmatrix} $ </td>
#     <tr>
#         <td> Reflexão em torno da <b>reta y = x</b> </td>
#         <td> $$w_{1} = y$$ $$w_{2} = x$$ </td>
#         <td> $\begin{bmatrix}
#                       0 & 1 \\
#                       1 & 0 \\
#                       \end{bmatrix}$ </td>
# </table>

# 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
get_ipython().run_line_magic('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))


# #### 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))


# #### 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))


# 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:

# <table>
#     <tr>
#         <td><b> Operador </b></td>
#         <td><b> Equações </b></td>
#         <td><b> Matriz Canônica </b></td>
#     <tr>
#         <td> Reflexão em torno do <b>plano xy</b> </td>
#         <td> $$w_{1} = x$$ $$w_{2} = y$$ $$w_{3} = -z$$ </td>
#         <td> $\begin{bmatrix}
#                       1 & 0 & 0 \\
#                       0 & 1 & 0 \\
#                       0 & 1 & -1 \\
#                       \end{bmatrix}$ </td>
#     <tr>
#         <td> Reflexão em torno do <b>plano xz</b> </td>
#         <td> $$w_{1} = x$$ $$w_{2} = -y$$ $$w_{3} = z$$ </td>
#         <td> $\begin{bmatrix}
#                       1 & 0 & 0 \\
#                       0 & -1 & 0 \\
#                       0 & 1 & 1 \\
#                       \end{bmatrix}$ </td>
#     <tr>
#         <td> Reflexão em torno do <b>plano yz</b> </td>
#         <td> $$w_{1} = -x$$ $$w_{2} = y$$ $$w_{3} = z$$ </td>
#         <td> $\begin{bmatrix}
#                       -1 & 0 & 0 \\
#                       0 & 1 & 0 \\
#                       0 & 1 & 1 \\
#                       \end{bmatrix}$ </td>
# </table>

# 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))


# #### 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))


# #### 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))


# ### Projeções

# Considere o operador $T: R^{n}$ &rarr; $R^{n}$  que leva cada vetor na sua **projeção ortogonal** sobre os eixos.

# <table>
#     <tr>
#         <td><b> Operador </b></td>
#         <td><b> Equações </b></td>
#         <td><b> Matriz Canônica </b></td>
#     <tr>
#         <td> Projeção ortogonal sobre o <b>eixo x</b> </td>
#         <td> $$w_{1} = x$$ $$w_{2} = 0$$ </td>
#         <td> $\begin{bmatrix}
#                       1 & 0 \\
#                       0 & 0 \\
#                       \end{bmatrix}$ </td>
#     <tr>
#         <td> Projeção ortogonal sobre o <b>eixo y</b> </td>
#         <td> $$w_{1} = 0$$ $$w_{2} = y$$ </td>
#         <td> $\begin{bmatrix}
#                       0 & 0 \\
#                       0 & 1 \\
#                       \end{bmatrix}$ </td>
# </table>

# 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))


# #### 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))


# 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:

# <table>
#     <tr>
#         <td><b> Operador </b></td>
#         <td><b> Equações </b></td>
#         <td><b> Matriz Canônica </b></td>
#     <tr>
#         <td> Projeção ortogonal sobre o <b>plano xy</b> </td>
#         <td> $$w_{1} = x$$ $$w_{2} = y$$ $$w_{3} = 0$$ </td>
#         <td> $\begin{bmatrix}
#                       1 & 0 & 0 \\
#                       0 & 1 & 0 \\
#                       0 & 0 & 0 \\
#                       \end{bmatrix}$ </td>
#     <tr>
#         <td> Projeção ortogonal sobre o <b>plano xz</b> </td>
#         <td> $$w_{1} = x$$ $$w_{2} = 0$$ $$w_{3} = z$$ </td>
#         <td> $\begin{bmatrix}
#                       1 & 0 & 0 \\
#                       0 & 0 & 0 \\
#                       0 & 0 & 1 \\
#                       \end{bmatrix}$ </td>
#     <tr>
#         <td> Projeção ortogonal sobre o <b>plano yz</b> </td>
#         <td> $$w_{1} = 0$$ $$w_{2} = y$$ $$w_{3} = z$$ </td>
#         <td> $\begin{bmatrix}
#                       0 & 0 & 0 \\
#                       0 & 1 & 0 \\
#                       0 & 0 & 1 \\
#                       \end{bmatrix}$ </td>
# </table>  

# 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))


# #### 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))


# #### 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))


# ### Rotações

# Um operador que gira cada vetor em $R^{n}$ por um ângulo fixado &theta; é chamado uma rotação em $R^{n}$.

# <table>
#     <tr>
#         <td><b> Operador </b></td>
#         <td><b> Equações </b></td>
#         <td><b> Matriz Canônica </b></td>
#     <tr>
#         <td> Rotação pelo <b>ângulo &theta;</b> </td>
#         <td> $$w_{1} = x.cos(t) + y.sen(t)$$ $$w_{2} = -x.sen(t) + y.cos(t)$$ </td>
#         <td> $\begin{bmatrix}
#                       cos(t) & sen(t) \\
#                       -sen(t) & cos(t) \\
#                       \end{bmatrix}$ </td>
#         
# </table>

# 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))


# Vamos mudar o ângulo &theta; 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))


# As matrizes de transformação que serão utilizadas para realizar as rotações do  vetor em 3 dimensões estão ilustradas abaixo:

# <table>
#     <tr>
#         <td><b> Operador </b></td>
#         <td><b> Equações </b></td>
#         <td><b> Matriz Canônica </b></td>
#     <tr>
#         <td> Rotação anti-horária em torno do eixo x positivo por um <b>ângulo &theta;</b> </td>
#         <td> $$w_{1} = x$$ $$w_{2} = y.cos(t) - z.sen(t)$$ $$w_{3} = y.sen(t) + z.cos(t)$$ </td>
#         <td> $\begin{bmatrix}
#                       1 & 0 & 0 \\
#                       0 & cos(t) & -sen(t) \\
#                       0 & sen(t) & cos(t) \\
#                       \end{bmatrix}$ </td>
#     <tr>
#         <td> Rotação anti-horária em torno do eixo y positivo por um <b>ângulo &theta;</b> </td>
#         <td> $$w_{1} = x.cos(t) + z.sen(t)$$ $$w_{2} = y$$ $$w_{3} = -x.sen(t) + z.cos(t)$$ </td>
#         <td> $\begin{bmatrix}
#                       cos(t) & 0 & sen(t) \\
#                       0 & 1 & 0 \\
#                       -sen(t) & 0 & cos(t) \\
#                       \end{bmatrix}$ </td>
#     <tr>
#         <td> Rotação anti-horária em torno do eixo z positivo por um <b>ângulo &theta;</b> </td>
#         <td> $$w_{1} = x.cos(t) - y.sen(t)$$ $$w_{2} = x.sen(t) + y.cos(t)$$ $$w_{3} = z$$ </td>
#         <td> $\begin{bmatrix}
#                       cos(t) & -sen(t) & 0 \\
#                       sen(t) & cos(t) & 0 \\
#                       0 & 0 & 1 \\
#                       \end{bmatrix}$ </td>
# </table>

# 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))


# #### 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))


# #### 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))


# ### 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 &le; k &le; 1 e uma **dilatação de razão k** se k &ge; 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.

# <table>
#     <tr>
#         <td><b> Operador </b></td>
#         <td><b> Equações </b></td>
#         <td><b> Matriz Canônica </b></td>
#     <tr>
#         <td> Contração de fator k em $R^{2}$ (0 &le; k &le; 1) </td>
#         <td> $$w_{1} = kx$$ $$w_{2} = ky$$ </td>
#         <td rowspan = "2" align = "center" valign = "center"> $\begin{bmatrix}
#                       k & 0 \\
#                       0 & k \\
#                       \end{bmatrix}$ </td>
#     <tr>
#         <td> Dilatação de fator k em $R^{2}$ (0 &ge; 1) </td>
#         <td> $$w_{1} = kx$$ $$w_{2} = ky$$ </td>
# </table>

# 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))


# 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))


# 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:

# <table>
#     <tr>
#         <td><b> Operador </b></td>
#         <td><b> Equações </b></td>
#         <td><b> Matriz Canônica </b></td>
#     <tr>
#         <td> Contração de fator k em $R^{3}$ (0 &le; k &le; 1) </td>
#         <td> $$w_{1} = kx$$ $$w_{2} = ky$$ $$w_{3} = kz$$ </td>
#         <td rowspan = "2" align = "center" valign = "center"> $\begin{bmatrix}
#                       k & 0 & 0 \\
#                       0 & k & 0 \\
#                       0 & 0 & k \\
#                       \end{bmatrix}$ </td>
#     <tr>
#         <td> Dilatação de fator k em $R^{3}$ (k &ge; 1) </td>
#         <td> $$w_{1} = kx$$ $$w_{2} = ky$$ $$w_{3} = kz$$ </td>
# </table>

# 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))


# 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))


# ### Alguma Dúvida? Entre em Contato Comigo:

# - [Me envie um e-mail](mailto:alysson.barbosa@ee.ufcg.edu.br);