結論

アークタンジェント(arctan)とは、タンジェントの値から角度を求める関数で、tan の逆関数です。プログラムでは atan(y/x) と atan2(y, x) の2つがあり、atan は -90°〜90° しか返さないため左半分の向きを区別できず、atan2 は x と y の符号を見て -180°〜180° の正しい向きを返します。座標から角度を求めるときは atan2 を使います。

この記事でわかること

  • アークタンジェントの意味、arctan・tan⁻¹・atan の書き方の違いと、atan と atan2 の違い
  • Python・JavaScript・C・Java・Go・Rust・Ruby・PHP と PostgreSQL・SQLite で同じ4点を計算し、atan(y/x) だと左半分で 180° ずれる実物と、エラー原文
  • ラジアンと度の変換、ゲームの「敵の方向」、地図の方位角、角度の差と平均を atan2 で求めた実測値

2026年10月29日更新|Python 3.13・Node.js 22・Java 21・gcc 13・Go 1.24・Rust 1.97・PostgreSQL 16・Chromium 153 で実行して確認

この記事で実際に動かしたもの:Ubuntu 24.04 の上で、8つのプログラミング言語の atan・atan2、NumPy・mawk・bc、作業用に立てた PostgreSQL 16(127.0.0.1 のみ)と SQLite の関数、Chromium の Canvas で「敵の方向」に矢印を回した描画、pyproj(WGS84 の測地線計算)と atan2 で求めた方位角の比較。

atan と atan2 の違いを先に図にします。

flowchart TD
    A[点の座標 x, y] --> B[atan に y/x を渡す]
    A --> C[atan2 に y と x を渡す]
    B --> D[-90度〜90度
右半分しか表せない] C --> E[-180度〜180度
4つの象限を区別]

よく調べられることの答えを先にまとめます。

知りたいこと 答え 詳しい節
アークタンジェントとは tan の値(傾き)から角度を返す、tan の逆関数 アークタンジェントとは
arctan と tan⁻¹ は同じ? 同じ。tan⁻¹ は「1/tan」ではない(1/tan 1 = 0.642、arctan 1 = 0.785) 場面で変わる書き方
atan と atan2 の違い atan は -90°〜90°、atan2 は -180°〜180°。atan2 は象限を区別する atanとatan2の違い
atan2 の引数の順番 ほとんどの言語で y が先、x が後(atan2(y, x)) 8言語で実行した結果
ラジアンを度にする 度 = ラジアン × 180 ÷ π。Python は math.degrees ラジアンと度の変換
結果を 0〜360° にしたい (度 + 360) % 360。-135° → 225° ラジアンと度の変換
atan2(0, 0) はエラー? 多くの言語でエラーにならず 0 を返す。-0 が混ざると ±180° になる 特別な値とエラー原文
ゲーム・地図での角度 ゲームは atan2(dy, dx)、方位角は atan2(東向きの差, 北向きの差) ゲーム・地図の節
arctan の微分 1/(1+x²)。x=1 で数値微分も 0.5 になった 微分と級数

確認環境:Ubuntu 24.04.5 LTS(2 CPU)。作業用のフォルダーで、Python 3.13.18(NumPy 2.5.3、作業用の venv に pyproj 3.8.0・PROJ 9.8.1)、Node.js 22.23.4、OpenJDK 21.0.12.1、gcc 13.3.0(glibc の libm)、Go 1.24.7、Rust 1.97.0、Ruby 3.3.6、PHP 8.3.6、mawk 1.3.4、bc 1.07.1、SQLite 3.53.1(Python の sqlite3)を実行しました。PostgreSQL 16.15 は作業用のフォルダーにデータベースを作り、127.0.0.1 だけで起動して t236db で関数を試し、終わってから削除して停止しています。ブラウザの動作は Playwright から Chromium 153.0.8010.12(Chrome for Testing)を動かし、Canvas の画素を読み取って確かめました。各関数の仕様は Python・MDN・Microsoft Learn(C ランタイム)・PostgreSQL・SQLite・NumPy の公式ドキュメントで確かめました。図は mermaid-cli で描画を確かめています(確認日 2026年10月29日)。

本記事の内容は、ご自由にお使いください。
ご利用の際は、出典として本ページへのリンクを記載いただけますようお願いします。

(記載例)出典:株式会社RJC「アークタンジェントとは?atanとatan2の違いを8言語・地図で実測」

アークタンジェントとは(tanの逆関数・角度を求める計算)

この節では、アークタンジェントが何を計算するものかと、値の例・定義域と値域が分かります。

アークタンジェントは、「タンジェントがこの値になる角度はいくつか」を返す関数です。タンジェント(tan)は角度から「傾き(高さ ÷ 横の長さ)」を求めますが、アークタンジェントはその逆向きで、傾きから角度を求めます。日本語では「逆正接(ぎゃくせいせつ)」とも呼びます。

たとえば、横に 1 進んで縦に 1 上がる坂の傾きは 1 です。tan 45° = 1 なので、arctan 1 = 45°(ラジアンでは π/4 = 0.785398…)になります。横 2・縦 1 の坂なら傾きは 0.5 で、arctan 0.5 = 26.565…° です。

1入力と出力

入力は傾き(どんな実数でもよい)、出力は角度。tan は「角度→傾き」、arctan は「傾き→角度」。

2値域は -90°〜90°

tan は 180° ごとに同じ値に戻るため、逆にするときは -90°〜90°(-π/2〜π/2)の1つだけを返すと決めている。

3覚えておく値

arctan 0 = 0°、arctan 1 = 45°、arctan √3 = 60°、arctan(-1) = -45°。傾きが大きくなるほど 90° に近づく。

Python で確かめると、次のとおりです。math.atan() の結果はラジアンなので、math.degrees() で度に直しています。

import math
print(math.atan(1), math.atan(-1), math.atan(math.sqrt(3)))
print(math.degrees(math.atan(0.5)))
print(math.tan(math.atan(5)))                          # tan と atan は逆の計算
print(math.degrees(math.atan(math.tan(math.radians(135)))))  # 135° は戻らない
print(math.atan(1e16), math.pi / 2)                    # 大きな傾きは 90° に近づく
0.7853981633974483 -0.7853981633974483 1.0471975511965976
26.56505117707799
5.000000000000001
-45.00000000000001
1.5707963267948966 1.5707963267948966

4行目が大事な点です。135° の tan を求めてから arctan で戻すと、135° ではなく -45° が返ります。tan 135° と tan(-45°) はどちらも -1 で、arctan は -90°〜90° の範囲の答えしか返さないためです。この「戻らない」性質が、次の節で扱う atan と atan2 の違いにつながります。3行目の 5.000000000000001 は、コンピューターの小数(浮動小数点数)の丸め誤差です。小数の誤差の仕組みは、関連記事「浮動小数点数とは|仕組み・誤差・0.1+0.2の理由を4言語で実演」で扱っています。

名前の「アーク(arc)」は「弧」の意味です。半径1の円(単位円)では、角度(ラジアン)と弧の長さが同じ数になるため、「tan がこの値になる弧の長さ」という意味で arc を付けて呼びます。アークサイン(arcsin)・アークコサイン(arccos)も同じ考え方です。

場面で変わるアークタンジェントの書き方(arctan・tan⁻¹・atan)

この節では、数学・電卓・プログラム・SQL で、アークタンジェントの書き方と単位がどう違うかが分かります。

同じアークタンジェントでも、書き方と結果の単位は場面ごとに違います。とくに tan⁻¹ の「-1」は逆関数の印で、マイナス1乗(逆数)ではありません。

場面 書き方 結果の単位 注意
数学(教科書) arctan x、tan⁻¹ x、Arctan x ラジアンが基本 tan⁻¹ x は 1/tan x ではない
関数電卓 tan⁻¹ キー(SHIFT+tan など) DEG・RAD の設定しだい 設定が RAD だと 45 ではなく 0.785 と出る
プログラム(1引数) atan(x)、Math.atan(x) ラジアン -π/2〜π/2 しか返さない
プログラム(2引数) atan2(y, x)、Math.atan2(y, x) ラジアン y が先。-π〜π を返す
SQL atan・atan2、PostgreSQL は atand・atan2d も ラジアン(d 付きは度) SQLite は数学関数が有効なビルドのみ

「tan⁻¹ は 1/tan ではない」ことは、数値で比べると一目で分かります。

import math
print("1 / tan(1) =", 1 / math.tan(1))   # 逆数(コタンジェント)
print("atan(1)    =", math.atan(1))       # 逆関数(アークタンジェント)
1 / tan(1) = 0.6420926159343306
atan(1)    = 0.7853981633974483

1/tan は「コタンジェント(cot)」という別の関数です。数学で sin² x と書くと「sin x の2乗」なのに、sin⁻¹ x は「逆関数」を意味するという書き方のずれがあり、混乱しやすい箇所です。迷ったときは arctan と書けば誤解されません。

atanとatan2の違い(象限で結果が変わる実物)

この節では、atan(y/x) と atan2(y, x) に同じ点を渡したとき、どこで結果が分かれるのかが分かります。

atan は「y/x」という1つの数しか受け取らないので、x と y の符号が分かりません。(1, 1) と (-1, -1) はどちらも y/x = 1 になり、atan では同じ 45° が返ります。atan2 は y と x を別々に受け取るので、(-1, -1) を正しく -135°(左下)と答えます。

点 (-1, -1)(左下)の向きを求める

atan(y/x)y/x = 1 になり、右上の (1, 1) と区別できない。45° と答え、180° ずれる。x = 0 のときは割り算で止まる言語もある
↔
atan2(y, x)y と x の符号を両方見るので -135° と正しく答える。x = 0 でも 90° か -90° を返す

座標・ベクトルから向きを求めるなら atan2。傾きの値しか無いなら atan

8つの方向の点を Python で両方の関数に渡した結果です。

import math
pts = [(1,1),(1,-1),(-1,1),(-1,-1),(0,1),(0,-1),(1,0),(-1,0)]
for x, y in pts:
    try:
        a = f"{math.degrees(math.atan(y/x)):.1f}"
    except ZeroDivisionError:
        a = "ZeroDivisionError"
    b = math.degrees(math.atan2(y, x))
    print(f"({x:2d},{y:2d}) | {a:>12} | {b:14.1f}")
( 1, 1) |         45.0 |           45.0
( 1,-1) |        -45.0 |          -45.0
(-1, 1) |        -45.0 |          135.0
(-1,-1) |         45.0 |         -135.0
( 0, 1) | ZeroDivisionError |           90.0
( 0,-1) | ZeroDivisionError |          -90.0
( 1, 0) |          0.0 |            0.0
(-1, 0) |         -0.0 |          180.0

結果を象限ごとに表にすると、ずれる場所がはっきりします。

点 (x, y) 位置 atan(y/x) atan2(y, x) 判定
(1, 1)第1象限(右上)45.0°45.0°一致
(-1, 1)第2象限(左上)-45.0°135.0°atan が 180° ずれる
(-1, -1)第3象限(左下)45.0°-135.0°atan が 180° ずれる
(1, -1)第4象限(右下)-45.0°-45.0°一致
(0, 1)真上ZeroDivisionError90.0°atan は計算できない
(-1, 0)真左-0.0°180.0°atan が 180° ずれる

(3, 4) のような半端な値でも同じです。(-3, 4) は atan で -53.13°、atan2 で 126.87°、(-3, -4) は atan で 53.13°、atan2 で -126.87° になりました。x が負(左半分)の点はすべて、atan だと 180° ずれます。

atan2を自作すると分かる象限の補正

atan2 が中でしていることは、atan の結果に「x が負なら ±180° を足す」補正です。補正を自分で書いて、乱数で選んだ100万点で math.atan2 と比べました。

import math, random
def my_atan2(y, x):
    if x > 0:  return math.atan(y / x)
    if x < 0 and y >= 0: return math.atan(y / x) + math.pi
    if x < 0 and y < 0:  return math.atan(y / x) - math.pi
    if y > 0:  return math.pi / 2
    if y < 0:  return -math.pi / 2
    return 0.0
random.seed(236)
mism = 0; maxerr = 0
for _ in range(1_000_000):
    x = random.uniform(-1, 1); y = random.uniform(-1, 1)
    e = abs(my_atan2(y, x) - math.atan2(y, x)); maxerr = max(maxerr, e)
    if e > 1e-15: mism += 1
print("1e-15より大きい差", mism, "件  最大差", maxerr)
for y, x in [(0.0,-1.0),(-0.0,-1.0),(0.0,0.0),(0.0,-0.0)]:
    print(f"y={y!r:5} x={x!r:5}  自作={my_atan2(y,x)!r:20}  math.atan2={math.atan2(y,x)!r}")
1e-15より大きい差 0 件  最大差 4.440892098500626e-16
y=0.0   x=-1.0   自作=3.141592653589793     math.atan2=3.141592653589793
y=-0.0  x=-1.0   自作=3.141592653589793     math.atan2=-3.141592653589793
y=0.0   x=0.0    自作=0.0                   math.atan2=0.0
y=0.0   x=-0.0   自作=0.0                   math.atan2=3.141592653589793

ふつうの点では差は最大 4.4×10⁻¹⁶(小数の最後の桁程度)で、補正の考え方は合っています。ただし -0.0(マイナスのゼロ)が混ざると、自作版と標準の atan2 で結果が分かれました。標準の atan2 は C 言語の規格どおり符号付きゼロを区別するためです。自作せず、言語の atan2 を使うのが確実です。

atan2 は 1961年の Fortran で導入されました。直交座標(x, y)から極座標(距離と角度)への変換で、象限の補正を毎回手で書かなくて済むようにするためです。

atan2を8言語で実行した結果(引数の順番と戻り値)

この節では、Python 以外の言語でも atan と atan2 の結果が同じになるかと、各言語での書き方・度への変換関数が分かります。

8言語すべてで、atan2 の引数は y が先・x が後で、結果は同じでした。同じ4点(右上・左上・左下・右下)を渡し、度に直して出力しています。

// JavaScript(Node.js 22。ブラウザでも同じ)
const P = [[1,1],[-1,1],[-1,-1],[1,-1]];
for (const [x, y] of P)
  console.log(`(${x},${y}) atan=${(Math.atan(y/x)*180/Math.PI).toFixed(1)} atan2=${(Math.atan2(y,x)*180/Math.PI).toFixed(1)}`);
/* C(gcc 13。-lm を付けてリンク) */
#include <stdio.h>
#include <math.h>
int main(void){
  double p[4][2]={{1,1},{-1,1},{-1,-1},{1,-1}};
  for(int i=0;i<4;i++){ double x=p[i][0], y=p[i][1];
    printf("(%g,%g) atan=%.1f atan2=%.1f\n", x, y, atan(y/x)*180/M_PI, atan2(y,x)*180/M_PI); }
  return 0;
}
// Java 21
double[][] p = {{1,1},{-1,1},{-1,-1},{1,-1}};
for (double[] q : p)
  System.out.printf("(%.0f,%.0f) atan=%.1f atan2=%.1f%n", q[0], q[1],
      Math.toDegrees(Math.atan(q[1]/q[0])), Math.toDegrees(Math.atan2(q[1], q[0])));
// Go 1.24
p := [][2]float64{{1, 1}, {-1, 1}, {-1, -1}, {1, -1}}
for _, q := range p {
    fmt.Printf("(%g,%g) atan=%.1f atan2=%.1f\n", q[0], q[1],
        math.Atan(q[1]/q[0])*180/math.Pi, math.Atan2(q[1], q[0])*180/math.Pi)
}
// Rust 1.97(メソッドの形。y.atan2(x) と書く)
let p = [(1.0f64, 1.0f64), (-1.0, 1.0), (-1.0, -1.0), (1.0, -1.0)];
for (x, y) in p {
    println!("({},{}) atan={:.1} atan2={:.1}", x, y, (y / x).atan().to_degrees(), y.atan2(x).to_degrees());
}
# Ruby 3.3 と PHP 8.3
ruby -e 'p [[1,1],[-1,1],[-1,-1],[1,-1]].map{|x,y| [x,y,(Math.atan(y.to_f/x)*180/Math::PI).round(1),(Math.atan2(y,x)*180/Math::PI).round(1)]}'
php -r 'foreach([[1,1],[-1,1],[-1,-1],[1,-1]] as [$x,$y]) printf("(%d,%d) atan=%.1f atan2=%.1f\n",$x,$y,rad2deg(atan($y/$x)),rad2deg(atan2($y,$x)));'

どの言語でも、出力は次の4行(Ruby は配列の形)になりました。

(1,1) atan=45.0 atan2=45.0
(-1,1) atan=-45.0 atan2=135.0
(-1,-1) atan=45.0 atan2=-135.0
(1,-1) atan=-45.0 atan2=-45.0
言語 atan2 の書き方 度への変換 y/x で x=0 のとき
Pythonmath.atan2(y, x)math.degrees(r)ZeroDivisionError
JavaScriptMath.atan2(y, x)r * 180 / Math.PIInfinity になり 90° が返る
Catan2(y, x)r * 180 / M_PIinf になり 90° が返る
JavaMath.atan2(y, x)Math.toDegrees(r)double は Infinity、int は ArithmeticException
Gomath.Atan2(y, x)r * 180 / math.Pi+Inf になり 90° が返る
Rusty.atan2(x)r.to_degrees()f64 は inf になり 90° が返る
RubyMath.atan2(y, x)r * 180 / Math::PI整数どうしは ZeroDivisionError
PHPatan2($y, $x)rad2deg($r)DivisionByZeroError

JavaScript・C・Go は 1/0 が無限大になり、atan(無限大) = 90° が返るので、真上・真下の点は atan でも止まりません。ただし x が負の点は同じように 180° ずれます。atan(y/x) は「止まる言語」と「黙って間違える言語」があり、どちらも atan2 に替えれば解決します。

Python 標準の math モジュールの関数を一覧で知りたい場合は、関連記事「Python mathモジュールの使い方|切り上げ・切り捨て・平方根と関数一覧」で扱っています。この記事では atan と atan2 に絞り、象限・特別な値・応用の計算を掘り下げます。

NumPy では np.arctan2(y, x) が配列をまとめて処理します。公式ドキュメントにも「y 座標が1番目の引数」と注記があります。手元で4点を渡すと [45. 135. -135. -45.] が返り、np.arctan(y/x) は [45. -45. 45. -45.] でした。mawk には atan2 だけがあり、atan(1) と書くと awk: line 2: function atan never defined で止まりました。bc は bc -l で a(x)(アークタンジェント)が使え、a(1)*4 は 3.14159265358979323844 でした。

なお、言語やツールによっては引数が (x, y) の順のもの(Mathematica の ArcTan[x, y] など)があります。初めて使う環境では、(-1, 1) を渡して 135° が返るかを1回確かめると、順番の取り違えにすぐ気づけます。

ラジアンと度の変換(degrees・radians・0〜360°にそろえる)

この節では、atan・atan2 が返すラジアンを度に直す方法と、-180°〜180° の結果を 0°〜360° にそろえる方法が分かります。

atan・atan2 の結果はラジアンです。度にするには 180/π をかけ、度からラジアンにするには π/180 をかけます。180° = π ラジアン(3.14159…)、1 ラジアンは約 57.3° です。

57.2958°1 ラジアン180 ÷ π の値
0.5236rad30°Java の toRadians(30) の結果
±180°atan2 の範囲atan は ±90°

度に直したあと、小数の誤差で「30」が「30.000000000000004」になることがあります。PostgreSQL の度で返す関数 atan2d でも同じでした。

Python: math.degrees(math.atan2(1, math.sqrt(3)))  → 30.000000000000004
Python: math.degrees(math.atan2(math.sqrt(3), 1))  → 59.99999999999999
Java:   Math.toDegrees(Math.PI / 6)                → 29.999999999999996
PostgreSQL 16: atan2d(1, sqrt(3))                  → 30.000000000000004
Python: round(math.degrees(math.atan2(1, math.sqrt(3))), 10) → 30.0

画面に出すときや比べるときは、round() で桁をそろえます。== で 30 と比べると一致しないので、「差が 1e-9 より小さいか」で判断します。

-180°〜180° を 0°〜360° にそろえる

atan2 の結果は負の角度も出ます。コンパスのように 0°〜360° で扱いたいときは、360 を足して 360 で割った余りを取ります。

 -135.0 -> (d+360)%360 =  225.0   d%360 =  225.0
  -90.0 -> (d+360)%360 =  270.0   d%360 =  270.0
   -0.0 -> (d+360)%360 =    0.0   d%360 =    0.0
  180.0 -> (d+360)%360 =  180.0   d%360 =  180.0

Python の % は割る数と同じ符号の余りを返すので、d % 360 だけでも 0〜360 になります。JavaScript・C・Java・Go の %(fmod)は割られる数の符号になり、-135 % 360 は -135 のままです。言語をまたいで同じ書き方にするなら ((d % 360) + 360) % 360 が確実です。

自分で確かめる(ターミナルで1行):Mac・Linux のターミナルで awk 'BEGIN{print atan2(1,-1)*180/atan2(0,-1)}' を実行すると、135 と出ます(atan2(0,-1) が π になるのを利用しています)。Python が入っていれば python3 -c "import math; print(math.degrees(math.atan2(1,-1)))" で 135.0 です。どちらも手元で同じ結果を確かめました。

atan2の特別な値(0・-0・無限大)とエラー原文

この節では、atan2(0, 0) や無限大を渡したときに何が返るかと、言語ごとのエラーの原文が分かります。

atan2(0, 0) は数学では向きが決まりませんが、ほとんどの言語ではエラーにならず 0 を返します。Microsoft Learn の C ランタイムの説明にも「atan2 のパラメーターが両方とも 0 の場合、関数は 0 を返します」とあります。ただし -0.0 が混ざると ±π(±180°)が返ります。

JavaScript: atan2(0,0) = 0   atan2(0,-0) = 3.141592653589793   atan2(-0,-0) = -3.141592653589793
Python:     atan2(0,0) = 0.0 atan2(0,-0.0) = 3.141592653589793 atan2(-0.0,-0.0) = -3.141592653589793
C:          atan2(0,0) = 0   atan2(0,-0.0) = 3.14159
Go:         Atan2(0,0) = 0   Atan2(0,math.Copysign(0,-1)) = 3.141592653589793
Rust:       0f64.atan2(-0.0) = 3.141592653589793
Ruby/PHP:   atan2(0,-0.0) = 3.141592653589793
SQLite:     select atan2(0,0) → 0.0     PostgreSQL: atan2(0,0) → 0

-0.0 は計算の途中で自然に生まれます。たとえば -1 * 0.0 や、負の小さな数が丸められて 0 になったときです。真左の点で atan2(0.0, -5) は 180° ですが、atan2(-0.0, -5) は -180° になりました。どちらも同じ向きですが、数値で比べると 360° 違うので、角度を比べる処理では次の節の「差の求め方」を使います。

無限大と極端な値の結果です(Python)。

atan(inf) = 1.5707963267948966     atan2(inf,inf) = 0.7853981633974483
atan(1e-10) = 1e-10
atan2(1e-300,-1e300) = 3.141592653589793   atan(1e-300/-1e300) = -0.0

最後の行は、y/x が小さすぎて 0 に丸められ、atan ではほぼ真左の点が 0°(真右)になった例です。atan2 は割り算をせずに角度を求めるので、正しく 180° を返しました。

エラーの原文

Python  math.atan2(1)      → TypeError: atan2 expected 2 arguments, got 1
Python  math.atan("1")     → TypeError: must be real number, not str
Python  math.atan(1/0)     → ZeroDivisionError: division by zero
Java    1/0(int)          → Exception in thread "main" java.lang.ArithmeticException: / by zero
Ruby    Math.atan(1/0)     → ZeroDivisionError: divided by 0
PHP     atan(1/0)          → DivisionByZeroError: Division by zero
SQLite  select atan2(1)    → OperationalError: wrong number of arguments to function atan2()
PostgreSQL select atan2(1) → ERROR:  function atan2(integer) does not exist

JavaScript は Math.atan2('1', '1') のように文字列を渡しても数値に直して 0.785… を返し、Math.atan2(NaN, 1) は NaN を返しました。エラーにならないぶん、入力の型の間違いに気づきにくい点に気をつけます。

Rust は型を書かないと止まります。1.0.atan2(1.0) は次のエラーになり、1.0_f64 のように型を付けると通りました。

error[E0689]: can't call method `atan2` on ambiguous numeric type `{float}`
 --> e.rs:1:24
  |
1 | fn main(){ let a = 1.0.atan2(1.0); println!("{}",a); }
  |                        ^^^^^
help: you must specify a concrete type for this numeric value, like `f32`

C で #include <math.h> を書き忘れると、gcc 13 は warning: implicit declaration of function 'atan2' と note: include '<math.h>' or provide a declaration of 'atan2' を出しました。警告でも放置せず、ヘッダーを書きます。

ゲームでアークタンジェントを使う(敵の方向・画面のy軸は下向き)

この節では、ゲームで「キャラクターから見た相手の方向」を atan2 で求める手順と、画面座標で気をつける点が分かります。

2つの点の角度は、差 dx = 相手の x − 自分の x、dy = 相手の y − 自分の y を取り、atan2(dy, dx) で求めます。求めた角度で弾を飛ばしたり、矢印やキャラクターを相手の方へ回したりできます。

1

差を取る

dx = 相手.x − 自分.x、dy = 相手.y − 自分.y。順番を逆にすると角度が 180° 反対になる。

引き算の順番

2

atan2(dy, dx) で角度を出す

y が先。結果はラジアンで、多くの描画 API(Canvas の rotate など)はラジアンのまま受け取る。

度に直さなくてよい場面が多い

3

向きに回す・進める

回転は rotate(角度)。進むなら x += 速さ × cos(角度)、y += 速さ × sin(角度)。

cos が x、sin が y

4

座標の向きを確かめる

画面座標は y が下向き。数学の式(y が上向き)をそのまま写すと上下が逆になる。

ここで間違えやすい

Chromium の Canvas で、自分 (100, 100) から右上の敵 (200, 50) へ矢印を回して描き、矢印の先の画素を読み取りました。

const player = {x: 100, y: 100}, enemy = {x: 200, y: 50};
const dx = enemy.x - player.x, dy = enemy.y - player.y;   // 100, -50
const a = Math.atan2(dy, dx);                             // 画面座標のまま渡す
g.save(); g.translate(player.x, player.y); g.rotate(a);
g.fillStyle = 'rgb(255,0,0)'; g.fillRect(0, -2, 60, 4); g.restore();
// 矢印の先(距離58)の画素を読む
const tx = Math.round(player.x + 58*Math.cos(a)), ty = Math.round(player.y + 58*Math.sin(a));
g.getImageData(tx, ty, 1, 1).data;
// 誤り:数学の向き(y が上)に直そうとして dy の符号を反転
const aw = Math.atan2(-dy, dx);
書き方 角度 矢印の先の座標 その画素(RGBA)
atan2(dy, dx)-26.565°(152, 74)=右上255, 0, 0, 255(赤い矢印の上)
atan2(-dy, dx)26.565°(152, 126)=右下0, 0, 0, 0(何も無い)

画面座標では、atan2(dy, dx) をそのまま使えば向きが合います。画面の y は下向きですが、Canvas の rotate も「正の角度で時計回り」なので、y を反転させずにそろったまま描けます。数学の教科書どおり「上が正」に直そうとして dy の符号を変えると、矢印は上下が反対の右下を向きました。CSS の transform: rotate(-0.4636rad) にも同じ角度を渡せ、計算された値は matrix(0.894427, -0.447214, 0.447214, 0.894427, 0, 0) でした。

敵へ向かって 1 フレームに 3 ピクセル進むなら、x に 3 × cos(a) = 2.683、y に 3 × sin(a) = -1.342 を足します。斜めでも速さが 3 のまま変わらないのが、角度を使う利点です。

自分で確かめる(ブラウザの開発者ツールで1行):Chrome や Edge で F12(Mac は Command+Option+I)を押して「コンソール」を開き、Math.atan2(1, -1) * 180 / Math.PI と入力すると 135 と表示されます。Chromium 153 で同じ式を評価し、135 が返ることを確かめました。

2D ゲームを作り始めるところは、関連記事「Godot Engineとは|始め方・GDScript・2Dゲームの作り方を解説」で扱っています。

地図でアークタンジェントを使う(方位角はatan2の引数を入れ替える)

この節では、2地点の緯度・経度から「北から時計回りに何度の方向か(方位角)」を atan2 で求める方法と、近似の誤差が分かります。

数学の角度は「東が 0°・反時計回り」ですが、地図の方位角は「北が 0°・時計回り」です。atan2(y, x) の引数を入れ替えて atan2(東向きの差, 北向きの差) とすると、方位角がそのまま出ます。

数学・ゲームの角度 atan2(y, x)

東(右)が 0°

反時計回りが正(北は 90°)

範囲は -180°〜180°

地図の方位角 atan2(x, y) % 360

北が 0°

時計回りが正(東は 90°)

0°〜360° にそろえて使う

北:   atan2(y,x)=  90.0  atan2(x,y)%360=   0.0
東:   atan2(y,x)=   0.0  atan2(x,y)%360=  90.0
南:   atan2(y,x)= -90.0  atan2(x,y)%360= 180.0
西:   atan2(y,x)= 180.0  atan2(x,y)%360= 270.0
北東: atan2(y,x)=  45.0  atan2(x,y)%360=  45.0

緯度・経度から方位角を求める式は、地球を球とみなすと次のようになります。経度の差をそのまま横の長さにすると、緯度が高いほど東西の長さが縮むことを無視してしまうため、cos(緯度) を含む式を使います。

import math
def bearing(lat1, lon1, lat2, lon2):
    p1, p2 = math.radians(lat1), math.radians(lat2)
    dl = math.radians(lon2 - lon1)
    x = math.sin(dl) * math.cos(p2)                                   # 東向きの成分
    y = math.cos(p1) * math.sin(p2) - math.sin(p1) * math.cos(p2) * math.cos(dl)  # 北向きの成分
    return (math.degrees(math.atan2(x, y)) + 360) % 360

東京駅(35.681236, 139.767125)から4地点への方位角を、3つの方法で求めて、楕円体(WGS84)の測地線計算(pyproj の Geod.inv)と比べました。座標は駅・空港・タワー付近の代表的な値です。

区間(距離) 測地線 WGS84 球面の式 atan2 経度に cos をかけた平面 緯度経度そのまま
東京駅→スカイツリー(5.1km)50.95°50.82°50.83°56.51°
東京駅→大阪駅(403.8km)255.64°255.57°254.34°257.09°
東京駅→札幌駅(831.4km)8.95°8.91°9.41°12.10°
東京駅→那覇空港(1562.1km)231.04°230.90°227.62°231.95°

球面の式は、どの区間でも測地線との差が 0.14° 以内でした。緯度・経度をそのまま x・y として atan2 に渡すと、5km 先のスカイツリーでも 5.6° ずれます。近い距離なら経度の差に cos(緯度) をかけるだけでも 0.1° 程度に収まりますが、数百 km を超えると 1°〜3° ずれました。正確さが要る測量・航法では、球面の式か楕円体の計算(pyproj などのライブラリ)を使います。

角度の差と平均もatan2で求める(350°と10°の問題)

この節では、0°/360° をまたぐ角度の差や平均を、atan2 を使って正しく求める方法が分かります。

角度は 360° で一周して戻るので、ふつうの引き算や平均では答えを間違えます。sin と cos に分けてから atan2 で角度に戻すと、一周の切れ目をまたいでも正しく計算できます。

--角度の差(現在350°→目標10°)
単純な差 tgt-cur = -340
atan2で求めた差 = 19.999999999999993  round -> 20.0
剰余で求めた差 ((tgt-cur+180)%360)-180 = 20
--角度の平均(風向 350°, 10°, 20°)
算術平均 = 126.66666666666667
atan2(Σsin, Σcos) = 6.704953

350° を向いているキャラクターを 10° へ向けるとき、単純な差 -340° のとおりに回ると大回りになります。atan2(sin(差), cos(差)) で差を -180°〜180° に収めると、時計回りに 20° だけ回ればよいと分かります。整数の度なら剰余の式でも同じ 20 になります。

北寄りの風(350°・10°・20°)の平均は、算術平均だと 126.7°(南東)という間違った答えになりました。各角度の sin・cos の合計を atan2 に渡すと 6.7°(北)で、見た目の感覚と合います。センサーの向きや風向の平均を出すときの決まった書き方です。NumPy の np.unwrap も、170°・179°・-179°・-170° の並びを 170・179・181・190 と連続した値に直しました。

2つのベクトルのなす角を求める方法には、内積と arccos を使うやり方もあります。arccos は 0°〜180° しか返さないので「どちら回りか」は分かりません。回る向きまで知りたいときは、外積(2次元なら x1·y2 − y1·x2)と内積を atan2 に渡して atan2(外積, 内積) とすると、-180°〜180° の符号付きの角度になります。内積・外積そのものは、関連記事「内積・外積とは|公式と計算例・使い道をNumPyで実演」で扱っています。

SQLでアークタンジェントを使う(PostgreSQL・SQLite)

この節では、データベースの中で atan・atan2 を計算する書き方と、データベースごとの違いが分かります。

PostgreSQL には度で返す atand・atan2d があり、SQLite は数学関数を有効にしてビルドされている場合だけ atan・atan2 が使えます。作業用に立てた PostgreSQL 16.15 での結果です。

select atan(1) as atan1, atan2(1,-1) as atan2_rad, atan2d(1,-1) as atan2d,
       atand(1) as atand1, degrees(atan2(-1,-1)) as deg, radians(180) as rad;
       atan1        |     atan2_rad     | atan2d | atand1 | deg  |        rad
--------------------+-------------------+--------+--------+------+-------------------
 0.7853981633974483 | 2.356194490192345 |    135 |     45 | -135 | 3.141592653589793
(1 row)

SQLite(Python の sqlite3、SQLite 3.53.1)でも同じ値でした。

select atan(1), atan2(1,-1), degrees(atan2(1,-1)), radians(180)
  -> (0.7853981633974483, 2.356194490192345, 135.0, 3.141592653589793)
select atan2(0,0) -> (0.0,)

SQLite の公式ドキュメントでは、数学関数はコンパイル時の -DSQLITE_ENABLE_MATH_FUNCTIONS で有効になると説明されています。手元では Python 3.13(SQLite 3.53.1)・Node.js 22 の node:sqlite(SQLite 3.53.4)・PHP 8.3 の SQLite3 のどれでも使えましたが、数学関数を有効にしていないビルドでは「関数が無い」というエラーになります。使う前に select atan2(1,-1); を1回試します。

データベース ラジアンで返す 度で返す 確かめ方
PostgreSQL 16atan(x)、atan2(y, x)atand(x)、atan2d(y, x)手元で実行
SQLite 3.53atan(X)、atan2(Y, X)degrees(atan2(Y, X))手元で実行(数学関数が有効なビルド)

アークタンジェントの微分と級数(数値で確かめる)

この節では、arctan の微分の結果と、arctan を使って円周率を求める級数が、数値でどうなるかが分かります。

arctan x の微分は 1/(1+x²) です。数式の証明は数学の教科書に任せ、ここでは数値微分(x の前後わずかの差で傾きを測る)と比べました。

x=0: 数値微分=1.000000000  1/(1+x^2)=1.000000000
x=1: 数値微分=0.500000000  1/(1+x^2)=0.500000000
x=3: 数値微分=0.100000000  1/(1+x^2)=0.100000000

arctan 1 = π/4 なので、4 × atan(1) は円周率になります(JavaScript でも Python でも 3.141592653589793 で、Math.PI と一致)。arctan x を x − x³/3 + x⁵/5 − … の級数で計算すると、x = 1 のときは収束がとても遅く、マチンの公式(π/4 = 4 arctan(1/5) − arctan(1/239))だと速く収束しました。

4*atan(1)の級数 10項: 3.0418396189 誤差 9.98e-02
4*atan(1)の級数 1000項: 3.1405926538 誤差 1.00e-03
4*atan(1)の級数 100000項: 3.1415826536 誤差 1.00e-05
マチンの公式 各10項: 3.141592653589792 誤差 1.33e-15

Python で100万回ずつ呼び出した時間(5回の最小値)も測りました。atan2 は atan より遅いものの、1回あたり 0.06 マイクロ秒ほどで、ふつうのプログラムで差が問題になることはまずありません。

34.5msatan(0.7) を100万回Python 3.13・timeit
59.5msatan2(0.7, 1.0) を100万回同じ条件
69.2msdegrees(atan2(…)) を100万回度への変換込み

アークタンジェントのよくあるエラー・つまずき

この節では、atan・atan2 を使うときに起きやすい間違いと、その直し方が分かります。

症状 原因 直し方
左向きのはずが右向きになる(180° ずれる)atan(y/x) を使っているatan2(y, x) に替える
45 のはずが 0.785 と出る結果がラジアン180/π をかける(degrees・toDegrees)
上下・左右が反対を向くatan2 の引数が (x, y) の順y を先に書く。(-1, 1) で 135° になるか確かめる
ZeroDivisionError: division by zeroatan(y/x) で x = 0atan2(y, x) は x = 0 でも ±90° を返す
同じ向きなのに 180° と -180° になるy が -0.0角度は差で比べる。表示は (d+360)%360
-135 % 360 が -135 のままJavaScript・C などの % は符号が残る((d % 360) + 360) % 360
SQLite で atan2 が「関数が無い」と言われる数学関数が無効なビルド有効なビルドを使うか、アプリ側で計算する
方位角が数度ずれる緯度経度をそのまま x・y にした球面の式か、楕円体のライブラリを使う

コードを書いたあとに、次の4つを確かめると、ほとんどの間違いを防げます。

  • 1座標から角度を出す処理は atan2 になっているかatan(y/x) は左半分で 180° ずれる。8言語すべてで同じ結果だった
  • 2引数は (y, x) の順か(-1, 1) を渡して 135° が返れば順番は合っている
  • 3単位はラジアンか度か計算と描画はラジアンのまま、画面の表示だけ度にすると変換の取りこぼしが減る
  • 4角度の差・平均を引き算や算術平均で出していないかsin・cos に分けて atan2 で戻す

判断表:atanとatan2のどちらを使うか

この節では、手元の値と目的から、atan と atan2 のどちらを使えばよいかが分かります。

迷ったら atan2 を選びます。atan を選ぶのは、手元に「傾き」の値が1つだけあり、答えが -90°〜90° に収まると分かっている場合です。

  1. 12点の座標・ベクトル (x, y) がある → atan2(y, x)向き・回転・極座標への変換。ゲーム、ロボット、画像処理
  2. 2北 0°・時計回りの方位角が欲しい → atan2(東向き, 北向き)地図・コンパス。最後に 0〜360° にそろえる
  3. 3角度の差・平均を出す → atan2(sin, cos)0°/360° の切れ目をまたいでも正しい
  4. 4回る向きつきの2ベクトルのなす角 → atan2(外積, 内積)arccos は 0°〜180° しか返さない
  5. 5傾き(勾配・比率)の値が1つだけ → atan(傾き)坂の角度、グラフの傾き、レンズの画角など。結果は -90°〜90°
1

坂の角度

勾配 10%(横100・縦10)なら atan(0.1) = 5.71°。値が1つなので atan。

atan

2

マウスの方向

中心からマウスへの dx・dy を atan2(dy, dx)。左半分にも対応。

atan2

3

極座標への変換

距離は hypot(x, y)、角度は atan2(y, x)。(3, 4) は 5 と 53.13°。

atan2+hypot

4

複素数の偏角

Python の cmath.phase(-1+1j) は atan2(1, -1) と同じ 2.356…。

atan2 と同じ

角度・ベクトル・三角関数は、プログラミングで数学が直接役に立つ代表的な場面です。ほかにどんな計算を使うかは、関連記事「プログラミングに数学は必要か|得意なら生きる場面と、実際に使う計算」で扱っています。

アークタンジェントのよくある質問

この節では、アークタンジェントと atan2 について、よく調べられている疑問への答えが分かります。

Q. アークタンジェントとは簡単に言うと何ですか?
A. 傾き(縦 ÷ 横)から角度を求める計算です。tan の逆の計算で、arctan 1 = 45° のように使います。

Q. arctan と tan⁻¹ と atan は同じですか?
A. 同じ関数です。数学では arctan や tan⁻¹、プログラムでは atan と書きます。tan⁻¹ は 1/tan(逆数)ではありません。1/tan 1 = 0.642、arctan 1 = 0.785 で値が違います。

Q. atan と atan2 の違いは何ですか?
A. atan は値を1つ受け取り -90°〜90° を返します。atan2 は y と x を別々に受け取り、符号を見て -180°〜180° を返します。座標から角度を求めるなら atan2 を使います。

Q. atan2 の引数はなぜ y が先なのですか?
A. atan(y/x) の「y/x」と同じ並びにしたためで、1961年の Fortran からの決まりです。C・Python・JavaScript・Java・Go・Ruby・PHP・NumPy・PostgreSQL・SQLite はすべて y が先でした。

Q. atan2 の結果を度にするには?
A. 180/π をかけます。Python は math.degrees()、Java は Math.toDegrees()、Rust は to_degrees()、PHP は rad2deg()、PostgreSQL は atan2d() で直接度を返せます。

Q. atan2 の結果がマイナスになります。0〜360° にするには?
A. (d + 360) % 360 とします。-135° は 225° になります。JavaScript・C などでは ((d % 360) + 360) % 360 と書くと、どんな値でも 0〜360 に収まります。

Q. atan2(0, 0) はエラーになりますか?
A. 手元で試した言語・SQL ではすべて 0 を返し、エラーになりませんでした。ただし x が -0.0 だと 180° になります。長さ0のベクトルの向きは決まらないので、先に長さが0でないかを確かめます。

Q. 関数電卓で tan⁻¹ を押したら 0.785 と出ました。
A. 角度の単位が RAD(ラジアン)になっています。DEG に切り替えると 45 と出ます。0.785 × 57.2958 ≒ 45 です。

Q. arctan の微分は何ですか?
A. 1/(1+x²) です。x = 1 で 0.5、x = 3 で 0.1 になることを数値微分でも確かめました。

Q. arctan の値域はなぜ -90°〜90° なのですか?
A. tan は 180° ごとに同じ値を繰り返すので、逆にするときは答えを1つに決める必要があります。-90°〜90° の範囲なら tan のすべての値(実数全体)をちょうど1回ずつ取るため、この範囲を使います。

Q. ゲームで atan2 を使うとき、y を反転させるべきですか?
A. 画面座標(y が下向き)で計算し、同じ画面座標の rotate に渡すなら反転は要りません。Chromium の Canvas で試すと、反転させたほうが上下逆を向きました。y が上向きの座標系(数学のグラフ・一部のゲームエンジン)と混ぜるときだけ符号をそろえます。

まとめ

  • アークタンジェントは tan の逆関数で、傾きから角度を求めます。arctan・tan⁻¹・atan は同じもので、tan⁻¹ は 1/tan ではありません。
  • atan は -90°〜90°、atan2 は -180°〜180°。atan(y/x) は x が負の点で 180° ずれることを、8言語すべてで確かめました。座標から角度を出すなら atan2(y, x) です。
  • 結果はラジアン。度にするには 180/π をかけ、0〜360° にするには (d+360)%360。小数の誤差は round でそろえます。
  • ゲームは atan2(dy, dx) を画面座標のまま、地図の方位角は atan2(東向き, 北向き)。緯度経度をそのまま使うと 5km 先でも 5.6° ずれました。
  • 角度の差・平均は sin・cos に分けて atan2 で戻します。350°・10°・20° の平均は 126.7° ではなく 6.7° です。

参考・出典

この節では、この記事で仕様を確かめた公式ドキュメントが分かります(確認日 2026年10月29日)。

  • Python ドキュメント「math --- 数学関数」(atan・atan2・degrees・radians):https://docs.python.org/3/library/math.html
  • MDN Web Docs「Math.atan2()」:https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2
  • Microsoft Learn「atan、atanf、atanl、atan2、atan2f、atan2l」:https://learn.microsoft.com/ja-jp/cpp/c-runtime-library/reference/atan-atanf-atanl-atan2-atan2f-atan2l
  • PostgreSQL 16 文書「Mathematical Functions and Operators」:https://www.postgresql.org/docs/16/functions-math.html
  • SQLite「Built-In Mathematical SQL Functions」:https://sqlite.org/lang_mathfunc.html
  • NumPy「numpy.arctan2」:https://numpy.org/doc/stable/reference/generated/numpy.arctan2.html
  • Wikipedia「atan2」(Fortran での導入年、引数の順番の違い):https://en.wikipedia.org/wiki/Atan2

本記事の内容は、ご自由にお使いください。
ご利用の際は、出典として本ページへのリンクを記載いただけますようお願いします。

(記載例)出典:株式会社RJC「アークタンジェントとは?atanとatan2の違いを8言語・地図で実測」

株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。

WE ARE HIRING

RJCで一緒に開発しながら、
成長を楽しみませんか?

RJCは、Web・モバイル・AIを活用した開発プロジェクトで、テックリードやPM・PMOも活躍するシステム開発会社です。会社を知る、待遇を確かめる、話を聞いてみる。気になるところ見てみてください!

  • 127日年間休日
  • 12時間平均残業時間
  • 毎日ガチャ遊びココロも大切にする福利厚生。アマギフなどの賞品ラインナップ!

ほかにも、チケットレストラン、書籍読み放題、2年ごとの慰労報奨(休暇 or 金一封)、11期連続の黒字決算。

ABOUT RJC RJCがどんな会社か知る 考え方、研修、働き方、福利厚生、社員の前職まで。RJCのことが丸わかり! RJC丸わかりページへ JOB DESCRIPTION 仕事内容・待遇を見てみる 仕事内容、給与・待遇、選考の流れ。経験者も未経験も!応募前に知りたいこと、まとめました! 募集要項を見る ENTRY エントリーする エントリーは1〜2分・履歴書不要です。まずは話を聞いてみたい、という方でも歓迎です! エントリーフォームへ

成長のヒミツ、 ぜんぶ丸わかり