Algoritmos e Programação I

5 Arranjos e matrizes 5.1 Arranjos 5.3 Arranjos multidimensionais

Compre o e-book deste material aqui! Consulte outras formas de colaborar.

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}.

(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).$		(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.$		(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)

O submódulo de álgebra linear numpy.linalg contém a função numpy.linalg.norm para a computação da norma de arrays.

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.$		(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).$		(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).$		(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.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).$		(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}.

(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).$		(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