Recomposed
Canvas

atan, atan2 e atanh: Três Inversas Diferentes, Um Nome Confuso

Oct 9, 2026 · 7 min read

atan, atan2 e atanh: Três Inversas Diferentes, Um Nome Confuso

O que atan, atan2 e atanh realmente são

Três funções que compartilham um padrão de nomenclatura, cada uma invertendo algo diferente:

  • atan(ratio) inverte tan. Forneça a ela um único número, uma inclinação ou uma razão , e ela retorna um ângulo, sempre entre -90° e 90°.
  • atan2(dy, dx) também retorna um ângulo, mas a partir de dy e dx como dois números separados em vez de uma razão já dividida. Suas respostas cobrem o círculo completo, -180° a 180°, não apenas metade dele.
  • atanh(x) não tem nada a ver com ângulos. Ela inverte a , expandindo um número já espremido em (-1, 1) de volta para qualquer número real. A seção de desvio perto do final deste post trata disso separadamente.

atan e atan2 compartilham uma raiz e ambas invertem uma tangente; atanh compartilha apenas o padrão de nomenclatura com as outras duas.

A intuição

"" parece ser uma única função, então é tentador tratar atan, atan2 e atanh como grafias intercambiáveis da mesma ideia. Elas não são, e atan versus atan2 é especialmente onde essa suposição se quebra:

  • tan(angle) depende apenas da razão dy / dx. Dois pontos opostos, como (1, 1) e (-1, -1), produzem exatamente a mesma razão, porque 1 / 1 e -1 / -1 são ambos 1.
  • atan tem que retornar uma única resposta para essa razão. Ela escolhe 45°, que é correto para (1, 1) e errado para (-1, -1), que está, na verdade, em -135°.
  • atan2 existe especificamente para desfazer essa perda de informação. Ela lê dy e dx separadamente, então pode verificar o sinal de cada um e resolver corretamente todos os quatro quadrantes.

O exemplo de arraste-para-ângulo de sistemas de coordenadas de tela já se apoiou em atan2 exatamente por esse motivo. Este post permanece nesse único mecanismo o tempo suficiente para ver por que atan não pode fazer o mesmo trabalho, não importa como a entrada seja manipulada.

Exemplo concreto: a mesma razão, duas direções diferentes

import kotlin.math.atan
import kotlin.math.atan2
 
val dy1 = 1.0; val dx1 = 1.0     // para baixo e para a direita (y cresce para baixo na tela)
val dy2 = -1.0; val dx2 = -1.0   // para cima e para a esquerda, a direção oposta
 
// Mesma razão (1/1 == -1/-1), então atan retorna o mesmo ângulo para ambos,
// mesmo que os dois pontos apontem para direções opostas.
Math.toDegrees(atan(dy1 / dx1))   // 45.0
Math.toDegrees(atan(dy2 / dx2))   // 45.0 (errado, este ponto está em -135°)
 
// atan2 vê dy e dx separadamente em vez de uma razão já dividida, então
// consegue diferenciar corretamente os dois pontos.
Math.toDegrees(atan2(dy1, dx1))   // 45.0
Math.toDegrees(atan2(dy2, dx2))   // -135.0

atan não está com defeito aqui. Ela está respondendo à única pergunta que lhe foi feita, "qual ângulo tem essa tangente," e uma única razão genuinamente mapeia para dois ângulos diferentes, separados por 180°. atan2 é uma pergunta diferente: "qual ângulo leva a este ponto (dx, dy)," e essa tem uma resposta única para cada ponto, exceto a própria origem.

atan(dy/dx): 0°

atan2(dy, dx): 0° — atan gives 0 degrees, atan2 gives the correct 0 degrees

Screen

drag the dot

Arraste o ponto pelos quatro quadrantes. atan2 acompanha o ângulo verdadeiro durante todo o percurso. atan volta à mesma leitura sempre que o arraste cruza para o ponto espelhado do outro lado do centro, porque essa é a única entrada que ela consegue ver.

O fundamento

atan2(dy, dx) é uma inversa de dois argumentos. Enquanto atan(ratio) só vê a informação que sobrevive a uma divisão, atan2 recebe o numerador e o denominador antes de qualquer divisão, então consegue recuperar o quadrante que uma razão de um único argumento já havia descartado.

Não é uma variante de atan com padrões melhores. Ela resolve um problema estritamente maior: "em qual direção está este ponto," e não "qual ângulo tem essa tangente."

Em outros lugares: mesmo fundamento, framework diferente

  • JavaScript: Math.atan2(y, x) recebe os mesmos dois argumentos na mesma ordem, pelo mesmo motivo, até o caso extremo de (0, 0) abaixo.
  • GLSL: atan(y, x), a sobrecarga de dois argumentos do mesmo nome de função usado para a versão de um argumento, resolve o intervalo completo de -π a π em um fragment shader da mesma forma, comumente usado para transformar o deslocamento de um fragmento em relação a um centro em um ângulo para formas procedurais.
  • Swift: atan2(y, x), importado diretamente da libm do C sem rótulos de argumento, é a mesma função com o mesmo nome, porque a matemática subjacente, e o motivo pelo qual um segundo argumento é necessário, não muda entre linguagens.

Casos extremos

kotlin.math.atan2 no Android delega diretamente para o Math.atan2 da JVM, então herda uma resposta definida para toda entrada, incluindo a única entrada em que "a direção para este ponto" parece algo que não deveria ter resposta alguma: a origem.

import kotlin.math.atan
import kotlin.math.atan2
 
val dy = 0.0
val dx = -0.0   // zero negativo: um valor Double distinto e válido
 
dy / dx          // NaN (0/0 é indeterminado independentemente dos sinais envolvidos)
atan(dy / dx)    // NaN, então não há ângulo algum para ler
 
atan2(dy, dx)    // ~3.14159 (π)

atan2 nunca divide dy por dx, então ela nem chega a ser exposta à forma indeterminada 0/0. Ela lê o sinal de cada zero diretamente: dy positivo, dx negativo é lido como "apontando na direção negativa de x," que é π. Troque dx de volta para zero positivo e atan2 retorna zero positivo em vez disso, uma resposta diferente para um valor Double (-0.0) que == trata como igual a 0.0. atan, trabalhando a partir de uma razão que já havia colapsado para NaN, não tem como distinguir esses casos.

Onde mais atan2 aparece

Botões de arraste-para-girar e lógica de direção de orientação, como o demo de arraste-para-ângulo do post complementar sobre sistemas de coordenadas de tela, são duas entradas em uma lista muito mais longa. Toda vez que você precisa de direção a partir de um par (dx, dy) em vez de distância, atan2 geralmente é o caminho.

UI e interação por toque:

  • Botões e discos de arraste-para-girar (botões de volume, roda de cores, controles deslizantes circulares, seletores estilo relógio): o ângulo do centro até o ponto de toque determina a rotação.
  • Menus radiais/circulares: testar em qual fatia um toque caiu, calculando o ângulo do toque em relação ao centro do menu.
  • Classificação de direção de deslize: agrupar o atan2(dy, dx) de um deslize em intervalos de cima/baixo/esquerda/direita (ou 8 direções).
  • Elementos que seguem o ponteiro: uma seta ou indicador que sempre aponta para o cursor, um destaque de seleção radial.

Movimento e orientação:

  • Direção de orientação a partir de um vetor de velocidade: girar um sprite/objeto para olhar para onde está se movendo, usando atan2(dy, dx) do seu deslocamento por quadro.
  • Lógica de "olhar para"/apontar: rotação de torre, inimigo-encara- jogador em jogos, câmera-encara-alvo.
  • Entrada de joystick/controle: dividir o (x, y) bruto de um analógico em direção (ângulo) e magnitude (raio) para movimento em 8 direções ou tratamento de zona morta.
  • Rumo entre dois pontos: atan2(y2 - y1, x2 - x1) para navegação/pathfinding; a versão de rumo de GPS/bússola é a mesma ideia em uma esfera.

Gráficos e visualização de dados:

  • Geometria de arcos e gráficos de pizza: calcular o ângulo de início/fim de um segmento, ou, de forma inversa, em qual fatia um clique caiu.
  • Conversão cartesiano-para-polar em geral: sempre que você precisa de (r, θ) a partir de (x, y) em vez do contrário, o caso abrangente sob o qual todo item acima se encaixa.

Processamento de sinais e outros domínios:

  • Argumento de número complexo: atan2(imaginary, real) fornece o ângulo de fase de um número complexo.
  • Demodulação I/Q em DSP: recuperar a fase a partir de componentes em fase/quadratura.
  • Robótica: cálculos de rumo até um ponto de passagem a partir da posição atual e do alvo.

Uma inversa diferente: atanh

atan e atan2 desfazem uma função que produz ângulos. atanh desfaz tanh, a função de compressão da seção de intuição acima, e executar essa inversa de volta tem seu próprio formato: crescendo lentamente perto de zero, depois disparando para o infinito conforme sua entrada se aproxima de ±1, a imagem espelhada de quão rápido tanh se achata nas mesmas bordas.

Não há nenhum gesto de arraste ou rotação envolvido aqui. Esta é a mesma ideia de "função inversa" da seção de atan2, aplicada a um par completamente diferente de funções, e ela aparece bem longe do código de UI do Android, em lugares onde um valor é naturalmente limitado e algo mais adiante precisa dele sem limites de novo.

atanh(x): 0.693

tanh(atanh(x)): 0.600 — atanh of 0.60 is 0.693, and tanh of that round-trips back to 0.600

x = 0.60

Um exemplo concreto: um coeficiente de correlação r sempre cai em (-1, 1), o que torna estranho executar um teste de significância comum diretamente sobre ele, já que esses testes assumem algo mais próximo de uma distribuição normal. A é apenas atanh(r):

import kotlin.math.atanh
 
// r é limitado em (-1, 1); z não é, e esse é exatamente o ponto.
fun fisherZ(r: Double): Double = atanh(r)
 
fisherZ(0.6)    // 0.693
fisherZ(0.99)   // 2.647 (próximo da borda, então z cresce rápido aqui)

kotlin.math.atanh vem embutido na biblioteca padrão e roda bem no Android, só que raramente há um motivo para recorrer a ela em código de UI, já que código de UI costuma ser aquele que produz um valor limitado (um alpha, uma fração de progresso), não aquele que precisa desfazer o limite.

Modelo mental para usar de fato

Uma função inversa só pode retornar o que sua entrada permite que ela veja: atan vê uma única razão colapsada e precisa adivinhar um quadrante, atan2 vê dois números com sinal e não precisa adivinhar, e atanh vê um valor limitado e o expande de volta para o intervalo sem limites de onde tanh o havia espremido.

Keep reading

Related reads

Receba novos posts no seu e-mail