Bissetriz em Código

Sobre a Matemática

Bissetriz é uma semi-reta de origem no vértice do ângulo que o divide em dois ângulos congruentes.

Como a divisão de um ângulo por um inteiro conduz a um único resultado, podemos concluir que a bissetriz de um ângulo é única.

Sobre o Código

Na linguagem de programação Python,

import – é o comando usado para trazer bibliotecas externas ou módulos para o código.

numpy – é a biblioteca para cálculos numéricos, vetores, matrizes e funções matemáticas.

matplotlib – é a biblioteca de visualização gráfica.

.pyplot – é o submódulo do Matplotlib que fornece funções para criar gráficos de forma simples.

def – é a palavra‑chave usada para definir uma função.

float – é o tipo numérico que representa números reais (com casas decimais).

.deg2rad() – é a função do NumPy que converte graus para radianos.

.cos() – é a função que calcula o cosseno de um ângulo (em radianos).

.sin() – é a função que calcula o seno de um ângulo (em radianos).

.subplots() – cria uma figura e um ou mais eixos (áreas de desenho) no Matplotlib.

figsize= – é o parâmetro que define o tamanho da figura (largura, altura).

.arrow() – desenha uma seta em um gráfico Matplotlib.

head_width= – define a largura da ponta da seta.

length_includes_head= – indica se o comprimento total inclui a ponta da seta.

.linspace() – gera uma sequência de valores igualmente espaçados entre dois limites.

.plot() – desenha linhas ou curvas em um gráfico.

color= – define a cor de um elemento gráfico.

.text() – escreve texto em uma posição específica do gráfico.

fr'$ – inicia uma f-string com suporte a LaTeX (formatação matemática).

.1f – é a formatação numérica: 1 casa decimal em ponto flutuante.

circ$ – é a parte de uma expressão LaTeX que representa o símbolo de grau °.

ha= – horizontal alignment: alinhamento horizontal do texto (left, center, right).

va= – vertical alignment: alinhamento vertical do texto (top, center, bottom).

.set_xlim() – define os limites do eixo X.

.set_ylim() – define os limites do eixo Y.

.axhline() – desenha uma linha horizontal no gráfico.

.axvline() – desenha uma linha vertical no gráfico.

linewidth= – define a espessura de uma linha.

.set_title() – define o título do gráfico.

.legend() – exibe a legenda do gráfico.

loc= – define a posição da legenda (ex.: “upper right”).

.grid() – ativa ou configura a grade do gráfico.

linestyle= – define o estilo da linha (-, –, :, etc.).

alpha= – define a transparência (0 = invisível, 1 = opaco).

.show() – exibe o gráfico na tela.

print() – exibe texto no console.

try: – inicia um bloco que tenta executar um código que pode gerar erro.

except: – é o bloco executado caso ocorra um erro no try.

ValueError – é o tipo de erro lançado quando um valor é inválido (ex.: converter texto em número).

% – é o operador módulo: retorna o resto da divisão.

if: – é a estrutura condicional: executa um bloco se a condição for verdadeira.

else: – é o bloco executado quando o if é falso.

f"..{}" – é a f-string: permite inserir variáveis dentro de uma string.

__main__ – é o nome especial que indica que o arquivo está sendo executado diretamente.

# – é usado para criar comentários ao código, que são notas para se entender melhor o que o código faz.

Vamos ao código…

import numpy as np
import matplotlib.pyplot as plt

def plot_angle_and_bisector(theta_deg: float):
    """
    Plota um ângulo com vértice na origem e sua bissetriz.
    
    theta_deg: medida do ângulo em graus (entre 0 e 360).
    O ângulo é formado entre o eixo positivo x (0°) e o raio em theta_deg.
    """
    # Converte para radianos
    theta = np.deg2rad(theta_deg)
    
    # Vetores unitários para os lados do ângulo
    # Primeiro lado: ao longo do eixo x positivo (0°)
    x1, y1 = np.cos(0), np.sin(0)
    # Segundo lado: em theta
    x2, y2 = np.cos(theta), np.sin(theta)
    
    # Bissetriz: ângulo médio
    theta_bis = theta / 2
    xb, yb = np.cos(theta_bis), np.sin(theta_bis)
    
    # Cria figura
    fig, ax = plt.subplots(figsize=(6, 6))
    
    # Plota os lados do ângulo
    ax.arrow(0, 0, x1, y1, head_width=0.05, length_includes_head=True, color='blue', label='Lado 1')
    ax.arrow(0, 0, x2, y2, head_width=0.05, length_includes_head=True, color='green', label='Lado 2')
    
    # Plota a bissetriz
    ax.arrow(0, 0, xb, yb, head_width=0.05, length_includes_head=True, color='red', label='Bissetriz')
    
    # Arco para representar o ângulo original
    arc_t = np.linspace(0, theta, 100)
    arc_x = 0.4 * np.cos(arc_t)
    arc_y = 0.4 * np.sin(arc_t)
    ax.plot(arc_x, arc_y, color='black')
    ax.text(0.45 * np.cos(theta / 2), 0.45 * np.sin(theta / 2),
            fr'$\theta = {theta_deg:.1f}^\circ$', ha='center', va='center')
    
    # Arco para representar metade do ângulo (bissetriz)
    arc_t_half = np.linspace(0, theta_bis, 100)
    arc_x_half = 0.25 * np.cos(arc_t_half)
    arc_y_half = 0.25 * np.sin(arc_t_half)
    ax.plot(arc_x_half, arc_y_half, color='red', linestyle='--')
    ax.text(0.3 * np.cos(theta_bis / 2), 0.3 * np.sin(theta_bis / 2),
            fr'$\theta/2 = {theta_deg/2:.1f}^\circ$', color='red', ha='center', va='center')
    
    # Configurações do gráfico
    ax.set_xlim(-1.1, 1.1)
    ax.set_ylim(-1.1, 1.1)
    ax.set_aspect('equal', 'box')
    ax.axhline(0, color='gray', linewidth=0.5)
    ax.axvline(0, color='gray', linewidth=0.5)
    ax.set_title('Bissetriz de um ângulo e sua unicidade')
    ax.legend(loc='upper right')
    plt.grid(True, linestyle='--', alpha=0.3)
    plt.show()

def main():
    print("Visualização da bissetriz de um ângulo.")
    print("A bissetriz é a semi-reta que divide o ângulo em dois ângulos congruentes.")
    try:
        theta_deg = float(input("Digite a medida do ângulo em graus (por exemplo, 60, 120, 210): "))
    except ValueError:
        print("Entrada inválida. Usando valor padrão de 60 graus.")
        theta_deg = 60.0
    
    # Normaliza o ângulo para [0, 360)
    theta_deg = theta_deg % 360
    if theta_deg == 0:
        print("Um ângulo de 0° não possui abertura para ser bissetado de forma usual.")
    else:
        print(f"Ângulo escolhido: {theta_deg:.1f}°")
        print(f"A bissetriz terá direção correspondente a {theta_deg/2:.1f}° em relação ao eixo x positivo.")
    
    plot_angle_and_bisector(theta_deg)

if __name__ == "__main__":
    main()

Saída do código (valor de retorno)…

Visualização da bissetriz de um ângulo.
A bissetriz é a semi-reta que divide o ângulo em dois ângulos congruentes.
Ângulo escolhido: 60.0°
A bissetriz terá direção correspondente a 30.0° em relação ao eixo x positivo.

Fonte:

• Editora Didática Paulista. Ensino Didático 2000: Ensino Fundamental e Ensino Médio. Sorocaba: Editora Didática Paulista, [s.d.].
• Códigos e comentários gerados por Microsoft Copilot com revisão nossa.
• https://docs.python.org/pt-br/3/ [Documentação Oficial do Python]