結論
アークタンジェント(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 で求めた実測値
この記事で実際に動かしたもの: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)(左下)の向きを求める
座標・ベクトルから向きを求めるなら 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) | 真上 | ZeroDivisionError | 90.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 のとき |
|---|---|---|---|
| Python | math.atan2(y, x) | math.degrees(r) | ZeroDivisionError |
| JavaScript | Math.atan2(y, x) | r * 180 / Math.PI | Infinity になり 90° が返る |
| C | atan2(y, x) | r * 180 / M_PI | inf になり 90° が返る |
| Java | Math.atan2(y, x) | Math.toDegrees(r) | double は Infinity、int は ArithmeticException |
| Go | math.Atan2(y, x) | r * 180 / math.Pi | +Inf になり 90° が返る |
| Rust | y.atan2(x) | r.to_degrees() | f64 は inf になり 90° が返る |
| Ruby | Math.atan2(y, x) | r * 180 / Math::PI | 整数どうしは ZeroDivisionError |
| PHP | atan2($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° です。
度に直したあと、小数の誤差で「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) で求めます。求めた角度で弾を飛ばしたり、矢印やキャラクターを相手の方へ回したりできます。
差を取る
dx = 相手.x − 自分.x、dy = 相手.y − 自分.y。順番を逆にすると角度が 180° 反対になる。
atan2(dy, dx) で角度を出す
y が先。結果はラジアンで、多くの描画 API(Canvas の rotate など)はラジアンのまま受け取る。
向きに回す・進める
回転は rotate(角度)。進むなら x += 速さ × cos(角度)、y += 速さ × sin(角度)。
座標の向きを確かめる
画面座標は 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 16 | atan(x)、atan2(y, x) | atand(x)、atan2d(y, x) | 手元で実行 |
| SQLite 3.53 | atan(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 マイクロ秒ほどで、ふつうのプログラムで差が問題になることはまずありません。
アークタンジェントのよくあるエラー・つまずき
この節では、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 zero | atan(y/x) で x = 0 | atan2(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° に収まると分かっている場合です。
- 12点の座標・ベクトル (x, y) がある → atan2(y, x)向き・回転・極座標への変換。ゲーム、ロボット、画像処理
- 2北 0°・時計回りの方位角が欲しい → atan2(東向き, 北向き)地図・コンパス。最後に 0〜360° にそろえる
- 3角度の差・平均を出す → atan2(sin, cos)0°/360° の切れ目をまたいでも正しい
- 4回る向きつきの2ベクトルのなす角 → atan2(外積, 内積)arccos は 0°〜180° しか返さない
- 5傾き(勾配・比率)の値が1つだけ → atan(傾き)坂の角度、グラフの傾き、レンズの画角など。結果は -90°〜90°
坂の角度
勾配 10%(横100・縦10)なら atan(0.1) = 5.71°。値が1つなので atan。
atan
マウスの方向
中心からマウスへの dx・dy を atan2(dy, dx)。左半分にも対応。
atan2
極座標への変換
距離は hypot(x, y)、角度は atan2(y, x)。(3, 4) は 5 と 53.13°。
atan2+hypot
複素数の偏角
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期連続の黒字決算。