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)invertetan. 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 dedyedxcomo 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ãody / dx. Dois pontos opostos, como(1, 1)e(-1, -1), produzem exatamente a mesma razão, porque1 / 1e-1 / -1são ambos1.atantem 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°.atan2existe especificamente para desfazer essa perda de informação. Ela lêdyedxseparadamente, 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.
- →Screen Coordinate Systems Aren't CartesianThe drag-to-angle case this post keeps coming back to: why atan2 is the inverse that survives a y-down screen's flipped rotation direction.
- →Polar to Cartesian: What cos and sin Are Actually ComputingThe forward direction atan2 undoes: turning an angle and radius into an (x, y) point in the first place.
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.0atan 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.



