Vetores em duas dimensões

22 Oct, 2025

O que são vetores?

Uma reta orientada possui um sentido de percurso considerado positivo e indicado por uma seta.

Um segmento orientado é determinado por um par ordenado de dois pontos no espaço, onde o primeiro é a origem e o segundo a extremidade do segmento. Por exemplo, um segmento que vai do ponto $A$ até o ponto $B$ é denominado de $\overset{―}{A B}$ . É desenhado conforme a Figura 1.

segmento_orientado_modern

Figura 1 - segmento de reta orientado AB

Um segmento de reta $\overset{―}{C D}$ possui a mesma direção de $\overset{―}{A B}$ se as retas suporte que contêm os segmentos são paralelas ou coincidem.

Somente quando dois segmentos de reta possuem a mesma direção é que se pode comparar os sentidos dos segmentos.

Dois segmentos de reta são equipotentes quando possuem a mesma direção, sentido e comprimento. É representado geometricamente por $\overset{―}{A B} ~ \overset{―}{C D}$ .

segmentos_equipotentes_modern

Figura 2 - segmentos de reta equipotentes

Um vetor é o conjunto de todos os segmentos de reta equipotentes.

Quando observamos a natureza, podemos quantificar suas grandezas com números, como por exemplo, a massa dos corpos, a temperatura, o comprimento e o tempo. Não há necessidade de outra informação além do dado numérico para se entender o seu significado. Esse tipo de grandeza é chamada de escalar. No entanto, algumas grandezas físicas, como a velocidade e força, necessitam da representação da direção e sentido para que se compreenda seus efeitos e interações com outras grandezas.

Espaço Vetorial

Seja $V$ um conjunto não vazio munido das operações de adição " $+$ " e multiplicação por escalar " $\cdot$ " fechadas em $V$ . Ou seja:

Adição

$\forall μ, ν \in V, μ + ν \in V$

Multiplicação por escalar

$\forall α \in ℝ, \forall μ \in V, α μ \in V$

Seguem-se as seguintes propriedades em relação à adição e multiplicação:

Axiomas da adição

Associatividade

$(μ + ν) + ω = μ + (ν + ω) \forall μ, ν, ω \in V$

Comutatividade

$μ + ν = ν + μ \forall μ, ν \in V$

Elemento neutro (Identidade)

$\exists 0 \in V, \forall μ \in V tal que μ + 0 = 0 + μ = μ$

Elemento oposto

$\forall μ \in V, \exists (- μ) \in V tal que μ + (- μ) = (- μ) + μ = 0$

Axiomas da multiplicação

Para todo $μ, ν \in V$ e $α, β \in ℝ$ temos que:

Associatividade

$(α β) μ = α (β μ)$

Distributividade em relação à adição

$\begin{matrix} (α + β) μ & = α μ + β μ \\ α (μ + ν) & = α μ + α ν \end{matrix}$

Elemento neutro (Identidade)

$1 μ = μ$

Assim, denotamos o espaço vetorial $(V, +, \cdot)$ ou simplesmente $V$ quando estiverem claras suas operações.

Generalizações dos espaços vetoriais

Da definição acima, podemos obter espaços vetoriais diversos como $ℝ^{2}$ ou $ℝ^{3}$ ou do conjunto das matrizes com $m$ linhas e $n$ colunas, $M_{(m, n)}$ . Assim, dependendo do espaço vetorial considerado, seus vetores serão elementos do conjunto correspondente e obedecerão os axiomas relativos à adição e multiplicação já descritos.

O espaço vetorial $ℝ^{2}$

Por exemplo, o conjunto $V \in ℝ^{2} = {(x, y) ∣ x, y \in ℝ}$ é um espaço vetorial com as operações acima descritas da seguinte forma:

Adição de vetores em $ℝ^{2}$

(x_{1}, y_{1}) + (x_{2}, y_{2}) = (x_{1} + x_{2}, y_{1} + y_{2})

Multiplicação por escalar

α (x, y) = (α x, α y)

O espaço vetorial $V$ é definido como um par ordenado de números reais. A magnitude dos vetores em $ℝ^{2}$ pode ser calculada medindo-se a distância entre o ponto de origem e a extremidade do vetor da seguinte maneira:

$se \vec{v} = (v_{x}, v_{y}) \in ℝ^{2}, então, ‖ \vec{v} ‖ = \sqrt{v_{x}^{2} + v_{y}^{2}}$

\begin{matrix} se \vec{v} & = (15, 8) temos: \\ ‖ \vec{v} ‖ & = \sqrt{15^{2} + 8^{2}} \\ ‖ \vec{v} ‖ & = 17 \end{matrix}

norma

Figura 3 - Magnitude do vetor (15,8)

Vamos criar uma classe em Python que represente nossa definição matemática do espaço vetorial euclidiano em duas dimensões.

import numpy as np  # Importa a biblioteca numérica

# Cria a classe Vetor que é um vetor de duas dimensões
class Vetor(object):

    # Define os componentes do vetor como (x,y) ao inicializar uma instância
    def __init__(self, x, y):
        try:
            self.x = float(x)
            self.y = float(y)
        except ValueError:
            raise ValueError('x e y devem ser números reais')

    # Implementa a multiplicação do vetor por um escalar Vetor * n
    def __mul__(self, scalar):
        """Multiplica um vetor por um escalar elemento por elemento"""
        # Tenta converter scalar para um número do tipo float e gera um erro caso não seja possível
        try:
            scalar = float(scalar)
        except ValueError:
            raise ValueError(f'O argumento={scalar} deve ser um número real')
        # Retorna um vetor com o produto da operação
        return Vetor(scalar * self.x, scalar * self.y)

    # Método caso a multiplicação ocorra à direita n * Vetor
    def __rmul__(self, scalar):
        return self * scalar

    # Calcula o produto interno entre dois vetores
    def dot(self, other):
        """Calcula o produto interno de um vetor pelo outro."""
        if type(other) != Vetor:
            raise ValueError(f'O argumento={other} deve ser um Vetor')
        return self.x * other.x + self.y * other.y

    # Calcula o produto vetorial ou cruzado
    def cross(self, other):
        """Calcula o produto vetorial (cross product) de um vetor pelo outro."""
        if type(other) != Vetor:
            raise ValueError(f'O argumento={other} deve ser um Vetor')
        return self.x * other.y - self.y * other.x

    # Adiciona dois vetores
    def __add__(self, other):
        """Adiciona vetor v e w de mesma dimensão (cardinalidade)"""
        return Vetor(self.x + other.x, self.y + other.y)

    # Subtrai dois vetores, adicionando o primeiro com o oposto do segundo
    def __sub__(self, other):
        """Calcula a subtração de um Vetor pelo outro como a soma do primeiro com o inverso do segundo"""
        other = -1 * other
        return self + other

    @property
    def magnitude(self):
        """Calcula a magnitude do vetor em R^2 como a distância entre o ponto de origem e da extremidade do Vetor"""
        return np.sqrt(self.x**2 + self.y**2)

    def __eq__(self, other):
        if type(other) != Vetor:
            raise ValueError(f'O argumento={other} deve ser um Vetor')
        return self.x == other.x and self.y == other.y

    def __neq__(self, other):
        return not self.__eq__(other)

    def __repr__(self):
        return f'Vetor({self.x}, {self.y})'

Abaixo, vamos criar alguns vetores e escalares e, após isso, vamos testar os axiomas aditivos e multiplicativos que descrevemos acima:

import unittest

# Vamos recriar as variáveis para o teste
a = 2.0
b = 3.0

u = Vetor(2, 2)
u2 = Vetor(2, 2)
v = Vetor(3, 0)
w = Vetor(5, 6)
nulo = Vetor(0, 0)

class TestMetodosClasse(unittest.TestCase):
    def testa_igualdade(self):
        self.assertEqual(u, u2)

    def testa_desigualdade(self):
        self.assertNotEqual(u, w)

    def testa_multiplicação(self):
        self.assertEqual(u * 2, 2 * u)

    def testa_magnitude(self):
        self.assertEqual(u.magnitude, np.sqrt(u.x**2 + u.y**2))

    def testa_dot(self):
        self.assertAlmostEqual(u.dot(v) / (u.magnitude * v.magnitude), np.cos(np.pi / 4))

class TestAxiomasAdição(unittest.TestCase):
    def testa_associatividade(self):
        self.assertEqual((u + v) + w, (v + w) + u)

    def testa_comutatividade(self):
        self.assertEqual(u + v, v + u)

    def testa_identidade(self):
        self.assertEqual(u + nulo, u)

    def testa_oposto(self):
        self.assertEqual(u + (u * -1), nulo)

class TestAxiomasMultiplicação(unittest.TestCase):
    def testa_associatividade(self):
        self.assertEqual((a * b) * u, a * (b * u))

    def testa_distributividade_vetorial(self):
        self.assertEqual((a + b) * u, (a * u) + (b * u))

    def testa_distributividade_escalar(self):
        self.assertEqual(a * (u + v), a * u + a * v)

    def testa_identidade(self):
        self.assertEqual(1 * u, u)

unittest.main(argv=[''], exit=False)

Representando graficamente os vetores em $ℝ^{2}$

Vamos representar graficamente nosso vetor de duas dimensões e posicioná-lo na origem do plano cartesiano. Para isso, criaremos um vetor $\vec{u}$ que representa duas unidades no eixo x e três unidades no eixo y.

\vec{u} = (2, 3)

Lembrando que $\vec{u}$ é um representante dos vetores $(2, 3)$ . Escolhemos de forma arbitrária o vetor nulo $\vec{O}$ como origem para plotagem de $\vec{u}$ . Perceba como o vetor representa um 'deslocamento' de duas unidades no eixo $x$ e 3 unidades no eixo $y$ .

Para esses vetores unitários $(0, 1)$ e $(1, 0)$ dá-se o nome de versor. Encontra-se o vetor unitário normalizado de $\vec{u}$ como produto da razão de $\vec{u}$ pela sua magnitude:

\vec{r} = \frac{\vec{u}}{‖ u ‖}

As componentes unitárias do resultado da operação possuem mesmo sentido e direção que o vetor $\vec{u}$ , mas magnitude um. As componentes no plano coordenado cartesiano são grafadas como $\hat{i}$ e $\hat{j}$ no eixo $x$ e $y$ , respectivamente. Algebricamente, o vetor $\vec{u}$ pode ser representado como a soma dos versores.

# Importa a biblioteca de visualização do Python
import matplotlib.pyplot as plt

# Cria nosso vetor
u = Vetor(2, 3)

# Cria o vetor nulo
O = Vetor(0, 0)

# Cria a figura onde serão grafados os vetores
fig, ax = plt.subplots()

# Define o tamanho da nossa tela de plotagem
ax.set_xlim(-1, 3)
ax.set_ylim(-1, 4)

# Cria a figura do nosso vetor com origem em O
ax.quiver(O.x, O.y, u.x, u.y, angles='xy', scale_units='xy', headaxislength=5, scale=1, color='g')

# Mostra o gráfico na tela
plt.show()

Se multiplicarmos $\vec{u}$ por 2, dobraremos a sua magnitude (comprimento) mantendo sua direção e sentido. Multiplicar por -1 inverte o sentido do vetor (Figura 6).

fig, ax = plt.subplots()
ax.set_xlim(-1, 5)
ax.set_ylim(-5, 10)

# Aumenta o nosso vetor u em 2 vezes
v = 2 * u

# Inverte o vetor u
w = -1 * u

# Cria a figura do u com origem em O
ax.quiver(O.x, O.y, u.x, u.y, angles='xy', scale_units='xy', headaxislength=5, scale=1, color='g')
# Cria a figura do segundo u com origem no primeiro u
ax.quiver(u.x, u.y, u.x, u.y, angles='xy', scale_units='xy', headaxislength=5, scale=1, color='g')
# Cria a figura do vetor v
ax.quiver(O.x, O.y + 1, v.x, v.y, angles='xy', scale_units='xy', headaxislength=5, scale=1, color='r')
# Cria o vetor w
ax.quiver(u.x, u.y - 1, w.x, w.y, angles='xy', scale_units='xy', headaxislength=5, scale=1, color='y')
plt.show()

Iremos agora somar dois vetores e observar sua representação no espaço cartesiano.

v = Vetor(0, 4)
# Soma v com o vetor u
r = v + u

fig, ax = plt.subplots()
ax.set_xlim(-2, 5)
ax.set_ylim(-2, 10)

# Vetor u
ax.quiver(O.x, O.y, u.x, u.y, angles='xy', scale_units='xy', headaxislength=5, scale=1, color='g')

# Vetor v
ax.quiver(O.x, O.y, v.x, v.y, angles='xy', scale_units='xy', headaxislength=5, scale=1, color='b')

# Vetor resultado
ax.quiver(O.x, O.y, r.x, r.y, angles='xy', scale_units='xy', headaxislength=5, scale=1, color='r')

plt.show()

Podemos representar $\vec{u}$ com sua origem na extremidade de $\vec{v}$ . Agora é possível ver $\vec{r}$ como resultado de $\vec{r} = \vec{u} + \vec{v}$ . Assim, $\vec{r}$ se inicia na origem de $\vec{u}$ e termina na extremidade de $\vec{v}$ .

fig, ax = plt.subplots()
ax.set_xlim(-1, 5)
ax.set_ylim(-1, 10)

# Vetor u
ax.quiver(v.x, v.y, u.x, u.y, angles='xy', scale_units='xy', headaxislength=5, scale=1, color='g')

# Vetor v
ax.quiver(O.x, O.y, v.x, v.y, angles='xy', scale_units='xy', headaxislength=5, scale=1, color='b')

# Vetor resultado
ax.quiver(O.x, O.y, r.x, r.y, angles='xy', scale_units='xy', headaxislength=5, scale=1, color='r')

plt.show()

É possível representar a diferença entre dois vetores como a soma de um vetor com o oposto do segundo.

\vec{v} - \vec{u} = \vec{v} + (- \vec{u})

fig, ax = plt.subplots()
ax.set_xlim(-5, 5)
ax.set_ylim(-5, 10)

w = u - v

# Vetor u
ax.quiver(O.x, O.y, u.x, u.y, angles='xy', scale_units='xy', headaxislength=5, scale=1, color='g')

# Vetor v
ax.quiver(O.x, O.y, v.x, v.y, angles='xy', scale_units='xy', headaxislength=5, scale=1, color='b')
ax.quiver(O.x, O.y, -v.x, -v.y, angles='xy', scale_units='xy', headaxislength=5, scale=1, color='black')

# Vetor resultado
ax.quiver(O.x, O.y, w.x, w.y, angles='xy', scale_units='xy', headaxislength=5, scale=1, color='r')

plt.show()

No notebook com o código do texto, é possível modificar os valores e explorar as representações geométricas dos vetores no plano. Clique aqui!

Vetores em duas dimensões

O que são vetores?

Espaço Vetorial

Axiomas da adição

Associatividade

Comutatividade

Elemento neutro (Identidade)

Elemento oposto

Axiomas da multiplicação

Associatividade

Distributividade em relação à adição

Elemento neutro (Identidade)

Generalizações dos espaços vetoriais

O espaço vetorial ℝ2

Adição de vetores em ℝ2

Multiplicação por escalar

Representando graficamente os vetores em ℝ2

O espaço vetorial $ℝ^{2}$

Adição de vetores em $ℝ^{2}$

Representando graficamente os vetores em $ℝ^{2}$