Algoritmos e Programação I

5 Arranjos e matrizes 5.1 Arranjos 5.3 Arranjos multidimensionais

Material disponível para compra: e-book apostila. Consulte outras formas de colaboração aqui!

5.2 Vetores

O uso de arrays é uma das formas mais adequadas para fazermos a modelagem computacional de vetores. Entretanto, devemos ficar atentos que vetores e arranjos não são equivalentes. Embora, a soma/subtração e multiplicação por escalar são similares, a multiplicação e potenciação envolvendo vetores não estão definidas, mas para arranjos são operações elemento-a-elemento.

No que segue, vamos assumir que a biblioteca NumPy está importada, i.e.

⬇

1import numpy as np

Exemplo 5.2.1.

Podemos alocar os vetores

	$\displaystyle\boldsymbol{v}=(1,0,-2),$		(5.10)
	$\displaystyle\boldsymbol{w}=(2,-1,3),$		(5.11)

como arrays do NumPy

⬇

1v = np.array([1, 0, -2])

2w = np.array([2, -1, 3])

A soma dos vetores é uma operação elemento-a-elemento

	$\displaystyle\boldsymbol{v}+\boldsymbol{w}=(1,0,-2)+(2,-1,3)$		(5.12)
	$\displaystyle\text{}\quad=\left(1+2,0+(-1),-2+3\right)$		(5.13)
	$\displaystyle\text{}\quad=(3,-1,1)$		(5.14)

e a dos arrays é equivalente

⬇

1v+w

array([ 3, -1, 1])

A subtração dos vetores também é uma operação elemento-a-elemento

	$\displaystyle\boldsymbol{v}-\boldsymbol{w}=(1,0,-2)-(2,-1,3)$		(5.15)
	$\displaystyle\text{}\quad=\left(1-2,0-(-1),-2-3\right)$		(5.16)
	$\displaystyle\text{}\quad=(-1,1,-5)$		(5.17)

e a dos arrays é equivalente

⬇

1v-w

array([ -1, 1, -5])

Ainda, a multiplicação por escalar

	$\displaystyle 2\boldsymbol{v}=2(1,0,-2)$		(5.18)
	$\displaystyle\text{}\quad=\left(2\cdot 1,2\cdot 0,2\cdot(-2)\right)$		(5.19)
	$\displaystyle\text{}\quad=(2,0,-4)$		(5.20)

também é feita elemento-a-elemento, assim como com arrays

⬇

12*v

array([ 2, 0, -4])

Agora, para vetores, a multiplicação $\boldsymbol{v}\boldsymbol{w}$ , divisão $\boldsymbol{v}/\boldsymbol{w}$ , potenciação $\boldsymbol{v}^{2}$ não são operações definidas. Diferentemente, para arranjos são operações elemento-a-elemento

⬇

1v*w

array([ 2, 0, -6])

⬇

1v/w

array([ 0.5, -0., -0.66666667])

⬇

1v**2

array([1, 0, 4])

5.2.1 Funções vetoriais

Funções vetoriais $f:\mathbb{R}^{n}\to\mathbb{R}^{n}$ e funcionais $f:\mathbb{R}^{n}\to\mathbb{R}$ também podem ser adequadamente modeladas com o emprego de arrays do NumPy. A biblioteca também conta com várias funções matemáticas predefinidas, consulte

https://numpy.org/doc/stable/reference/routines.math.html

Exemplo 5.2.2.(Função vetorial)

A implementação da função vetorial $\boldsymbol{f}:\mathbb{R}^{3}\to\mathbb{R}^{3}$

\boldsymbol{f}(\boldsymbol{x})=(x_{1}^{2}+\sin(x_{1}),x_{2}^{2}+\sin(x_{2}),x_% {3}^{2}+\sin(x_{3}))

(5.21)

para $\boldsymbol{x}=(x_{1},x_{2},x_{3})\in\mathbb{R}^{3}$ , pode ser feita da seguinte forma

⬇

1import numpy as np

3def f(x):

4 return x**2 + np.sin(x)

6# exemplo

7x = np.array([0, np.pi, np.pi/2])

8print(f'y = {f(x)}')

Verifique!

5.2.2 Produto interno

O produto interno (ou, produto escalar) é a operação entre vetores $\boldsymbol{v},\boldsymbol{w}\in\mathbb{R}^{n}$ definida por

\boldsymbol{v}\cdot\boldsymbol{w}:=v_{1}w_{1}+v_{2}w_{2}+\cdots+v_{n}w_{n}% \mathchar 46\relax

(5.22)

A função numpy.dot computa o produto interno dos arrays.

Exemplo 5.2.3.

Consideramos os vetores

	$\displaystyle\boldsymbol{v}=(1,0,-2),$		(5.23)
	$\displaystyle\boldsymbol{w}=(2,-1,3)\mathchar 46\relax$		(5.24)

O produto interno desses vetores é

	$\displaystyle\boldsymbol{v}\cdot\boldsymbol{w}=v_{1}w_{1}+v_{2}w_{2}+v_{3}w_{3}$		(5.25)
	$\displaystyle\text{}\quad=1\cdot 2+0\cdot(-1)+(-2)\cdot 3$		(5.26)
	$\displaystyle\text{}\quad=2+0-6=-4\mathchar 46\relax$		(5.27)

Usando arrays, temos

⬇

1v = np.array([1, 0, -2])

2w = np.array([2, -1, 3])

3np.sum(v*w)

-4

⬇

1np.dot(v,w)

-4

5.2.3 Norma de vetores

A norma $L^{2}$ de um vetor $\boldsymbol{v}\in\mathbb{R}^{n}$ é definida por

\|\boldsymbol{v}\|:=\sqrt{v_{1}^{2}+v_{2}^{2}+\cdots+v_{n}^{2}}

(5.28)

Para um array, o submódulo de álgebra linear numpy.linalg contém a função numpy.linalg.norm para a computação dessa norma.

Exemplo 5.2.4.

A norma do vetor $\boldsymbol{v}=(3,0,-4)$ é

	$\displaystyle\\|\boldsymbol{v}\\|=\sqrt{v_{1}^{2}+v_{2}^{2}+v_{3}^{2}}$		(5.29)
	$\displaystyle\text{}\quad=\sqrt{3^{2}+0^{2}+(-4)^{2}}$		(5.30)
	$\displaystyle\text{}\quad=\sqrt{9+0+16}$		(5.31)
	$\displaystyle\text{}\quad=\sqrt{25}=5\mathchar 46\relax$		(5.32)

Usando o módulo numpy.linalg, obtemos

⬇

1import numpy as np

2import numpy.linalg as npla

3v = np.array([3, 0, -4])

4np.sqrt(np.dot(v,v))

5.0

⬇

1npla.norm(v)

5.0

5.2.4 Produto vetorial

O produto vetorial entre dois vetores $\boldsymbol{v},\boldsymbol{w}\in\mathbb{R}^{3}$ é definido por

	$\displaystyle\boldsymbol{v}\times\boldsymbol{w}:=\begin{vmatrix}\boldsymbol{i}% &\boldsymbol{j}&\boldsymbol{k}\\ v_{1}&v_{2}&v_{3}\\ w_{1}&w_{2}&w_{3}\end{vmatrix}$		(5.33)
	$\displaystyle\text{}\quad=\begin{vmatrix}v_{2}&v_{3}\\ w_{2}&w_{3}\end{vmatrix}\boldsymbol{i}$		(5.34)
	$\displaystyle\text{}\qquad-\begin{vmatrix}v_{1}&v_{3}\\ w_{1}&w_{3}\end{vmatrix}\boldsymbol{j}$		(5.35)
	$\displaystyle\text{}\qquad+\begin{vmatrix}v_{1}&v_{2}\\ w_{1}&w_{2}\end{vmatrix}\boldsymbol{k}$		(5.36)

A função numpy.cross computa o produto vetorial entre arrays (unidimensionais de 3 elementos).

Exemplo 5.2.5.

O produto vetorial entre os vetores $\boldsymbol{v}=(1,-2,1)$ e $\boldsymbol{w}=(0,2,-1)$ é

	$\displaystyle\boldsymbol{v}\times\boldsymbol{w}=\begin{vmatrix}\boldsymbol{i}&% \boldsymbol{j}&\boldsymbol{k}\\ 1&-2&1\\ 0&2&-1\end{vmatrix}$		(5.38)
	$\displaystyle\text{}\quad=0\boldsymbol{i}+\boldsymbol{j}+2\boldsymbol{k}$		(5.39)
	$\displaystyle\text{}\quad=(0,1,2)\mathchar 46\relax$		(5.40)

Com o NumPy, temos

⬇

1v = np.array([1, -2, 1])

2w = np.array([0, 2, -1])

3np.cross(v,w)

array([0, 1, 2])

5.2.5 Exercícios

E. 5.2.1.

Complete as lacunas.

a)

Usualmente, vetores são computacionalmente modelados como numpy.array.
b)

O produto interno de dois vetores alocados como arrays pode ser computado com o método numpy.dot.
c)

A norma $L^{2}$ de um vetor alocado como um numpy.array pode ser computado com o método numpy.linalg.norm.

a) numpy.array; b) numpy.dot; c) numpy.linalg.norm;

E. 5.2.2.

Considere os seguintes vetores

	$\displaystyle\boldsymbol{u}=(2,-1,1),$		(5.41)
	$\displaystyle\boldsymbol{v}=(1,-3,2),$		(5.42)
	$\displaystyle\boldsymbol{w}=(-2,-1,-3)\mathchar 46\relax$		(5.43)

Usando arrays do NumPy, compute:

a)

$\boldsymbol{u}\cdot\boldsymbol{v}$
b)

$\boldsymbol{u}\cdot(2\boldsymbol{v})$
c)

$\boldsymbol{u}\cdot(\boldsymbol{w}+\boldsymbol{v})$
d)

$\boldsymbol{v}\cdot(\boldsymbol{v}-2\boldsymbol{u})$

Dica: use a função $np\mathchar 46\relax dot()$ e verifique as computações calculando os resultados esperados.

E. 5.2.3.

Considere os seguintes vetores

	$\displaystyle\boldsymbol{u}=(2,-1,1),$		(5.44)
	$\displaystyle\boldsymbol{v}=(1,-3,2),$		(5.45)
	$\displaystyle\boldsymbol{w}=(-2,-1,-3)\mathchar 46\relax$		(5.46)

Usando arrays do NumPy, compute:

a)

$\|\boldsymbol{u}\|$
b)

$\|\boldsymbol{u}+\boldsymbol{v}\|$
c)

$|\boldsymbol{u}\cdot\boldsymbol{w}|$

Dica: use a função numpy.linalg.norm e verifique as computações calculando os resultados esperados.

E. 5.2.4.

Dados vetores $\boldsymbol{u}$ e $\boldsymbol{v}$ , temos que

\boldsymbol{u}\cdot\boldsymbol{v}=\|\boldsymbol{u}\|\|\boldsymbol{v}\|\cos\theta,

(5.47)

onde $\theta$ é o ângulo entre esses vetores. Implemente uma função que recebe dois vetores e retorna o ângulo entre eles. Teste seu código para diferentes vetores.

⬇

1import numpy as np

2import numpy.linalg as npla

4def angulo(v, w):

5 # \|v\|

6 norm_v = npla.norm(v)

7 # \|w\|

8 norm_w = npla.norm(w)

9 # u.v

10 vdw = np.dot(v, w)

11 # cos \theta

12 ct = udw/(norm_v*norm_w)

13 return np.acos(ct)

E. 5.2.5.

A projeção ortogonal do vetor $\boldsymbol{u}$ na direção do vetor $\boldsymbol{v}$ é definida por

\operatorname{proj}_{\boldsymbol{v}}\boldsymbol{u}:=\frac{\boldsymbol{u}\cdot% \boldsymbol{v}}{\|\boldsymbol{v}\|^{2}}\boldsymbol{v}\mathchar 46\relax

(5.48)

Implemente uma função que recebe dois vetores $\boldsymbol{u}$ , $\boldsymbol{v}$ e retorne a projeção de $\boldsymbol{u}$ na direção de $\boldsymbol{v}$ . Teste seu código para diferentes vetores.

⬇

1import numpy as np

2import numpy.linalg as npla

4def proj(u, v):

5 # \|v\|

6 norm_v = npla.norm(v)

7 # u.v

8 udv = np.dot(u, v)

9 # proj_v u

10 proj_vu = udv/norm_v**2 * v

11 return proj_vu

E. 5.2.6.

Considere os vetores

	$\displaystyle\boldsymbol{u}=(2,-3,1),$		(5.49)
	$\displaystyle\boldsymbol{v}=(1,-2,-1)\mathchar 46\relax$		(5.50)

Usando arrays do NumPy, compute os seguintes produtos vetoriais:

a)

$\boldsymbol{u}\times\boldsymbol{v}$
b)

$\boldsymbol{v}\times(2\boldsymbol{v})$

Dica: use a função numpy.cross e verifique as computações calculando os resultados esperados.

Envie seu comentário

Aproveito para agradecer a todas/os que de forma assídua ou esporádica contribuem enviando correções, sugestões e críticas!

Este texto é disponibilizado nos termos da Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional. Ícones e elementos gráficos podem estar sujeitos a condições adicionais.

Política de uso de dados

Política de uso de dados

Algoritmos e Programação I

5.2 Vetores

Exemplo 5.2.1.

5.2.1 Funções vetoriais

Exemplo 5.2.2.(Função vetorial)

5.2.2 Produto interno

Exemplo 5.2.3.

5.2.3 Norma de vetores

Exemplo 5.2.4.

5.2.4 Produto vetorial

Exemplo 5.2.5.

5.2.5 Exercícios

E. 5.2.1.

E. 5.2.2.

E. 5.2.3.

E. 5.2.4.

E. 5.2.5.

E. 5.2.6.

Envie seu comentário