Vetores e sua implementação em numpy

# Pacotes necessários. Resolva essas dependências antes de prosseguir!
import matplotlib.pyplot as plt
import numpy as np

O pacote numpy permite representar vetores e implementar imediatamente suas operações:

import numpy as np

x1 = 4
x2 = 5
x = np.array( [x1, x2] )

y = np.array( [-4, -5])

print(x)
print(2*x)
print(x+y)

z = 10*(x + 2*y)
print(z)

[4 5]
[ 8 10]
[0 0]
[-40 -50]

Exercício 1: relacionar um vetor à hipotenusa de um triângulo retângulo

Veja a figura abaixo. A seta correspondente ao vetor cobre a hipotenusa de um triângulo retângulo.

  1. Qual é o comprimento do cateto azul?
  2. Qual é o comprimento do cateto vermelho?
  3. Qual é o comprimento do vetor representado (dica: use o Teorema de Pitágoras)? Faça um código em Python que permite verificar sua resposta.
plt.figure(figsize=(5,5))
plt.arrow(0,0,1,2,length_includes_head=True,head_width=0.1)
plt.plot([0,1], [0,0],'r')
plt.plot([1,1], [0,2],'b')
plt.xlim([-1,2])
plt.ylim([-1,2])
plt.grid()
plt.show()
No description has been provided for this image

Exercício 2: calcular o módulo de vetores em duas dimensões

O comprimento da seta que representa um vetor no plano cartesiano é chamado de módulo do vetor. Dependendo da referência bibliográfica, o módulo é também chamado de norma, ou de comprimento. O módulo de um vetor \(\boldsymbol {x}\) é representado usando barras verticais. Duas notações comuns são: \(|\boldsymbol{x}|\) e \(||\boldsymbol{x}||\). Como vimos, de acordo com o Teorema de Pitágoras, o módulo de um vetor de duas dimensões pode ser calculado por:

\[ ||\boldsymbol{x}|| = \sqrt{x_1^2 + x_2^2} \]

Calcule (manualmente, e depois confira suas contas com um programa! se achar necessário, faça um desenho) os módulos dos vetores:

  1. \([3, 4]\)
  2. \([6, 8]\)
  3. \([9, 12]\)
  4. \([-3, 4]\)
  5. \([-3, -4]\)
  6. \([3, -4]\)

Exercício 3: calcular módulo de vetores em dimensão alta

Quando um vetor tem mais de duas dimensões (por exemplo, \(n\) dimensões), o Teorema de Pitágoras pode ser generalizado para encontrar o módulo:

\[ ||\boldsymbol{x}|| = \sqrt{x_1^2 + x_2^2 + x_3^2 + ... + x_n^2} \]

Faça um programa em Python para encontrar o módulo do vetor \(\boldsymbol {x}\) definido abaixo. Seu programa deve funcionar também para calcular o módulo do vetor \(\boldsymbol {y}\), que tem tamanho definido aleatoriamente a cada nova execução. Implemente seu cálculo usando um laço explícito, iterando sobre as dimensões dos vetores. Após, confira sua reposta comparando com a instrução np.linalg.norm(x).

x = np.array([4, -2, 3, 2, 0.5, 0, 1, 2, 1, 3, 2, -1, 0.123, 0.432, 1.1212])
y = np.random.random(np.random.randint(30,70))

Usar a representação polar de vetores

Exercício 4: calcular o ângulo entre um vetor e o eixo horizontal

Neste exercício, calcularemos o ângulo entre o eixo horizontal (eixo x) e a seta que representa o vetor. Esse ângulo representa a direção do vetor e geralmente é referido como \(\theta\) (a letra grega theta). O ângulo é comumente chamado de argumento.

  1. Qual é o comprimento do vetor \(\boldsymbol{v}\) representado abaixo?
  2. Qual dos ângulos do triângulo formado na figura é \(\theta\)?
  3. Qual é a tangente de \(\theta\)?
  4. Usando seus conhecimentos de trigonometria, calcule \(\theta\) em radianos e em graus.
  5. Usando a função np.arctan, calcule \(\theta\) em radianos e em graus.
  6. Usando a função np.arctan2, calcule \(\theta\) em radianos e em graus.
  7. Repita o exercício para \(\boldsymbol{v} = [1,2]\)
import numpy as np
import matplotlib.pyplot as plt 
v = np.array([1, 1])
plt.figure(figsize=(5,5))
plt.arrow(0,0,v[0],v[1],length_includes_head=True,head_width=0.1)
plt.plot([0,v[0]], [0,0],'r')
plt.plot([v[0],v[0]], [0,v[1]],'b')
plt.xlim([-1,3])
plt.ylim([-1,3])
plt.grid()
plt.show()
No description has been provided for this image

Exercício 5: calcular o efeito de multiplicações por escalares no módulo e no argumento de vetores

Manipule o vetor \(\boldsymbol{v}\) no código abaixo para responder às seguintes questões: 1. Inicialmente, calcule o módulo e o argumento de \(\boldsymbol{v}\). 2. Calcule o módulo e o argumento de \(2 \boldsymbol{v}\) 3. Escolha um número positivo qualquer \(a\) e calcule o módulo e o argumento de \(a \boldsymbol{v}\) 4. Escolha um número negativo qualquer \(b\) e calcule o módulo e o argumento de \(b \boldsymbol{v}\) 5. Escreva: o que acontece com o módulo e o argumento de um vetor quando o vetor é multiplicado por um número qualquer?

v = np.array([1, 1])
plt.figure(figsize=(5,5))
plt.arrow(0,0,v[0],v[1],length_includes_head=True,head_width=0.1)
plt.plot([0,v[0]], [0,0],'r')
plt.plot([v[0],v[0]], [0,v[1]],'b')
plt.xlim([-1,3])
plt.ylim([-1,3])
plt.grid()
plt.show()
No description has been provided for this image

Exercício 6: deduzir matematicamente o procedimento para normalizar um vetor

Quando dois vetores têm o mesmo argumento, dizemos que eles têm a mesma direção.

Se temos um vetor \(\boldsymbol{v}\) com módulo \(||\boldsymbol{v}||\), como podemos encontrar um vetor \(\boldsymbol{w}\) com a mesma direção de \(\boldsymbol{v}\) e com módulo igual a 1?

Implemente a função normalizar(v : np.ndarray) que retorna um vetor com módulo 1 e com a mesma direção de v. Implemente também testes que verifiquem que a função funciona corretamente.

def normalizar(v: np.ndarray) -> np.ndarray:
    return v

Exercício 7: usar operações vetoriais de numpy para calcular o módulo de vetores

As três funções abaixo retornam o módulo de um vetor recebido como entrada. 1. Verifique se essas funções retornam resultados corretos 2. Qual das implementações você acha mais compacta? Por que?

def modulo_A(x):
    mod = 0
    for i in range(len(x)):
        mod += x[i]**2
    mod = mod**0.5
    return mod

def modulo_B(x):
    mod = np.sqrt (np.sum(x**2))
    return mod

def modulo_C(x):
    mod = np.linalg.norm(x)
    return mod

Exercício 8: implementar uma trajetória usando Python

Uma partícula parte da origem do plano cartesiano e executa as seguintes instruções:

  1. caminha na direção do vetor $\(\begin{bmatrix} 0 \\ 1\end{bmatrix}\)$ por uma distância de 5,
  2. vira 60 graus no sentido horário
  3. caminha por uma distância de 7
  4. vira 30 graus no sentido anti-horário
  5. caminha por uma distância de 3, chegando ao ponto marcado pelo vetor \(v\)
  6. vira novamente de \(\phi\) graus no sentido horário, apontando agora para a origem
  7. caminha até a origem

Nessa situação:

  1. Use o pacote matplotlib.pyplot para fazer uma figura que corresponde à trajetória da partícula
  2. Use Python para fazer um programa que calcula o ângulo \(\phi\) em graus
  3. Use Python para escrever \(v\) na forma cartesiana e, após, na forma polar.
import matplotlib.pyplot as plt
import numpy as np

x = np.array([0, 0])