Dart数値型の深淵：`int`、`double`、そして`num`の真実 – 低レイヤから見抜く精度の落とし穴と最適化の秘密
長年、Dart VM のコア開発と大規模分散システムのアーキテクチャ設計に携わってきた者として、今回は開発者の間では意外と見過ごされがちな、Dart における数値型の内実に迫りたい。`var`、`final`、`const` の宣言子に隠された型推論の妙、そして `int` と `double` の内部表現、さらには `num` 型を扱う際の注意点について、コンパイラ、ランタイム、そしてプラットフォームの壁を超えた視点から、その真髄を解き明かしていく。
1. Dart における数値型の基本：`int` と `double` の役割
Dart では、整数は `int`、浮動小数点数は `double` で表現される。これらは、他の言語でよく見られるような、ビット幅による固定的な型（例: `int32_t`, `float64_t`）とは一線を画す。Dart の `int` は、プラットフォームのネイティブ整数型で表現できる範囲であれば、それに準じた効率で扱われる。しかし、その範囲を超える場合は、arbitrary-precision arithmetic（任意精度演算）によって、いくらでも大きな整数を表現できる。`double` は、IEEE 754 標準の倍精度浮動小数点数（64-bit）で表現される。
1.1. コンパイラによる型推論と最適化の舞台裏
`var` キーワードを用いた変数宣言は、Dart の強力な型推論能力の恩恵を受ける。コンパイラは、代入される値の型から変数の型を推論し、その型情報に基づいて最適化を行う。
void main() {
var integerValue = 10; // Dartコンパイラはこれを int 型と推論します。
var doubleValue = 3.14; // Dartコンパイラはこれを double 型と推論します。
print(‘integerValue の型: ${integerValue.runtimeType}’); // 出力: int
print(‘doubleValue の型: ${doubleValue.runtimeType}’); // 出力: double
// integerValue = 3.14; // コンパイルエラー！型安全性が保証されます。
}
ここで重要なのは、`var` で宣言された変数は、初期化された値の型で固定されるということだ。一度 `int` として推論された `integerValue` に `double` 型の値を代入しようとすると、コンパイル時に型エラーが発生する。これは、Dart が静的型付け言語であることの現れであり、実行時エラーを防ぎ、コードの堅牢性を高める。
コンパイラは、これらの型情報を利用して、CPU のネイティブ命令にマッピング可能なコードを生成する。例えば、`int` 型の演算は、可能な限り高速な整数演算命令に変換される。`double` 型も、FPU (Floating-Point Unit) を活用した最適化が行われる。
1.2. `final` と `const`：不変性という名の防壁
`final` と `const` は、変数の値が一度設定されたら変更できないことを保証する。これらは、コードの意図を明確にし、予期せぬ副作用を防ぐための重要なメカニズムだ。
- `final`: 変数の値は一度だけ代入可能。その値は実行時に決定される。
- `const`: 変数の値はコンパイル時に決定される必要があり、不変であることが保証される。
void main() {
// final 変数: 実行時に値が決定
final String greeting = “Hello”;
// greeting = “Hi”; // コンパイルエラー！
// const 変数: コンパイル時に値が決定
const int maxAttempts = 3;
// maxAttempts = 5; // コンパイルエラー！
// final 変数でも、コンパイル時に既知の値であれば const のように扱われることがあります。
final int compileTimeKnownInt = 100;
const int compileTimeConstInt = 200;
print(‘greeting: $greeting’);
print(‘maxAttempts: $maxAttempts’);
print(‘compileTimeKnownInt: $compileTimeKnownInt’);
print(‘compileTimeConstInt: $compileTimeConstInt’);
// const 変数は、コンパイル時に評価されるため、定数式として利用されます。
// 例: switch 文の case ラベル、デフォルト引数など。
}
`const` は、コンパイル時の定数畳み込み（constant folding）という強力な最適化を可能にする。コンパイラは、`const` で宣言された変数の値をコンパイル時に計算し、その計算結果を直接コードに埋め込む。これにより、実行時の計算オーバーヘッドが削減される。
2. `num` 型の真実：抽象化の代償と型安全の境界線
`num` 型は、`int` と `double` の両方を受け入れることができる抽象基底クラスだ。これにより、コードの柔軟性が増すが、同時に注意すべき点も存在する。
void main() {
// num 型の変数
num value;
value = 10; // int 型を代入
print(‘value (int): $value, type: ${value.runtimeType}’); // 出力: value (int): 10, type: int
value = 3.14; // double 型を代入
print(‘value (double): $value, type: ${value.runtimeType}’); // 出力: value (double): 3.14, type: double
// num 型の変数に対して、int と double の両方で利用可能なメソッドを呼び出せます。
print(‘value.abs(): ${value.abs()}’); // 出力: value.abs(): 3.14
print(‘value.toString(): ${value.toString()}’); // 出力: value.toString(): 3.14
// num 型の変数に対して、int または double 専用のメソッドを直接呼び出そうとすると、
// コンパイルエラーまたは実行時エラーになる可能性があります。
// 例:
// print(‘value.isEven: ${value.isEven}’); // コンパイルエラー！ num には isEven メソッドはない。
// value as int; // Downcast が必要
// 安全な操作のためには、型チェックや型キャストが不可欠です。
if (value is int) {
print(‘value is an integer: ${value.isEven}’); // 出力: value is an integer: false (value は double なのでこのブロックには入らない)
} else if (value is double) {
print(‘value is a double: ${value.roundToDouble()}’); // 出力: value is a double: 3.0
}
}
`num` 型の変数に `int` と `double` の両方の値を代入できるのは便利だが、その実体は常に `int` か `double` のどちらかである。`num` 型自体は、`abs()` や `toString()` のような、`int` と `double` の両方に共通するメソッドしか直接提供しない。
注意点:
- 型安全性の低下: `num` 型を使用すると、具体的な型情報が失われるため、`int` 専用のメソッド（例: `isEven`）や `double` 専用のメソッド（例: `roundToDouble()`）を直接呼び出せなくなる。これらのメソッドを呼び出すには、`is` 演算子による型チェックや `as` 演算子による型キャストが必要になる。
- パフォーマンスへの影響: 型チェックや型キャストは、実行時に追加の処理を必要とするため、パフォーマンスにわずかながら影響を与える可能性がある。頻繁に型キャストが必要なロジックは、設計を見直す余地があるかもしれない。
- ランタイムの型情報: Dart VM は、`num` 型の変数であっても、その実際の型（`int` または `double`）をランタイムで保持している。`runtimeType` プロパティや `is` 演算子は、このランタイム情報を参照している。
3. プラットフォーム間の差異と精度の落とし穴
Dart は、JavaScript へのコンパイル（Web 環境）とネイティブコードへのコンパイル（モバイル、デスクトップ、サーバー）の両方に対応している。このクロスプラットフォーム性はDartの大きな強みだが、数値型の扱いで注意すべき点がある。
3.1. `int` の振る舞い：ネイティブ整数と任意精度
- ネイティブ環境 (VM, AOT): Dart の `int` は、プラットフォームのネイティブ整数型（通常は64ビット）で表現できる範囲内であれば、それをそのまま利用する。これにより、非常に高速な整数演算が実現される。
- 範囲外の整数: ネイティブ整数型の表現範囲を超える大きな整数は、Dart の `int` は任意精度演算ライブラリを用いて表現する。これは、内部的に多倍長整数として扱われるため、ネイティブ整数演算に比べてオーバーヘッドが増大する。
- JavaScript 環境: Web ブラウザ上では、Dart は JavaScript にコンパイルされる。JavaScript の数値型は、すべて IEEE 754 倍精度浮動小数点数として扱われる。したがって、Dart の `int` が JavaScript 環境で扱われる場合、その実体は JavaScript の `Number` 型（つまり `double`）となる。これにより、JavaScript の `Number.MAX_SAFE_INTEGER` (2^53 – 1) を超える整数を正確に扱えなくなる可能性がある。
void main() {
// 64-bit 整数として安全に表現できる範囲内の整数
int largeInt = 1234567890123456789;
print(‘largeInt: $largeInt, type: ${largeInt.runtimeType}’); // 出力: largeInt: 1234567890123456789, type: int
// JavaScript 環境での動作をシミュレート (実際には Dart VM 上で実行されるため、この挙動にはならない)
// もし JavaScript にコンパイルされた場合、この値は精度を失う可能性があります。
// console.log(Number.MAX_SAFE_INTEGER); // JavaScript の最大安全整数
// JavaScript の Number.MAX_SAFE_INTEGER を超える整数
int veryLargeInt = BigInt.parse(‘9007199254740992’).toInt(); // 2^53
int slightlyLargerInt = BigInt.parse(‘9007199254740993’).toInt(); // 2^53 + 1
print(‘veryLargeInt: $veryLargeInt, type: ${veryLargeInt.runtimeType}’);
print(‘slightlyLargerInt: $slightlyLargerInt, type: ${slightlyLargerInt.runtimeType}’);
// JavaScript 環境では、veryLargeInt と slightlyLargerInt は同じ値 (9007199254740992.0) になる可能性がある。
// Dart VM 上では正確に保持される。
}
`BigInt` の利用: JavaScript 環境での整数精度問題を回避したい場合や、ネイティブ整数型を超えた任意精度の整数演算を明示的に行いたい場合は、`BigInt` クラスを利用することを検討すべきだ。`BigInt` は、プラットフォームに関わらず、常に任意精度で整数を扱える。
3.2. `double` の精度：IEEE 754 の限界
Dart の `double` は、IEEE 754 倍精度浮動小数点数として実装されている。これは、科学計算やグラフィックスなど、多くの用途で十分な精度を提供するが、以下の点に注意が必要だ。
- 有限の精度: `double` は有限のビット数で実数を表現するため、すべての実数を正確に表現できるわけではない。特に、2進数で割り切れない小数は、近似値として格納される。
- 演算誤差: 浮動小数点数同士の演算は、累積的な誤差を生む可能性がある。特に、加算、減算、乗算、除算を繰り返す計算では、誤差が大きくなる傾向がある。
void main() {
// 2進数で割り切れない小数
double nonBinaryFraction = 0.1;
print(‘0.1 を double で表現: $nonBinaryFraction’); // 出力: 0.1 を double で表現: 0.1 (内部的には近似値)
// 0.1 + 0.2 の期待値と実際の結果
double sum = 0.1 + 0.2;
print(‘0.1 + 0.2 = $sum’); // 出力: 0.1 + 0.2 = 0.30000000000000004 (期待値 0.3 とは異なる)
// 比較時の注意
if (sum == 0.3) {
print(‘sum は 0.3 と等しいです (これは通常 false です)。’);
} else {
print(‘sum は 0.3 と等しくありません。’); // こちらが出力される
}
// 比較のためには、許容誤差（epsilon）を用いるのが一般的
double epsilon = 1e-10; // 許容誤差
if ((sum – 0.3).abs() < epsilon) {
print('sum は 0.3 に非常に近いです。');
}
}
対策:
- 等値比較の回避: 浮動小数点数の等値比較は避けるべきだ。代わりに、両者の差の絶対値が微小な許容誤差（epsilon）よりも小さいかどうかで判断する。
- `Decimal` 型の検討: 金融計算など、厳密な精度が求められる場合は、`package:decimal/decimal.dart` のような高精度 decimal 型ライブラリの利用を検討する。ただし、これらのライブラリは内部的に文字列や多倍長整数で数値を表現するため、ネイティブ `double` よりもパフォーマンスが低下する可能性がある。
4. ランタイムとイベントループ：数値計算がもたらす軽微な遅延
Dart VM は、シングルスレッドでイベントループを管理し、非同期処理を実行する。数値計算、特に複雑な浮動小数点演算や、`BigInt` を用いた任意精度演算は、CPU リソースを消費する。
イベントループとの関連:
- 同期的な計算: `int` や `double` による単純な計算は非常に高速であり、イベントループの処理にほとんど影響を与えない。
- 重い計算: 非常に大きな整数に対する複雑な演算や、多数の浮動小数点演算を同期的に行う場合、イベントループがブロックされる可能性がある。これは、特に UI スレッドで発生すると、アプリケーションの応答性を著しく低下させる原因となる。
- Isolate の活用: CPU バウンドな重い数値計算を行う場合は、Isolate を用いて別スレッドで処理を実行することを強く推奨する。Isolate は、メモリ空間を共有しない独立した実行環境であり、VM のイベントループをブロックすることなく、並列処理を実現できる。
import ‘dart:isolate’;
void main() async {
print(‘メインスレッド: 重い計算を開始します…’);
// 重い計算を別 Isolate で実行
final result = await computeHeavyCalculation();
print(‘メインスレッド: 計算結果: $result’);
print(‘メインスレッド: イベントループはブロックされず、他の処理も実行可能です。’);
}
// Isolate で実行される関数 (トップレベル関数である必要がある)
double complexCalculation(double input) {
// 例: 多数の浮動小数点演算
double result = input;
for (int i = 0; i < 1000000; i++) {
result = (result 1.000000001) + (result / 1.000000002);
// 意図的に誤差を蓄積させるような処理
result = result.sin() result.cos();
}
return result;
}
// compute() は、指定された関数を別 Isolate で実行し、結果を返します。
Future
final input = 1.23456789;
// `compute` は、Dart SDK に含まれる `package:basics/src/compute.dart` に由来するユーティリティ関数です。
// (実際には、isolate_group_channel.dart など、より低レベルなAPIを使っていますが、`compute` が高レベルな抽象化を提供します)
return await Isolate.run(() => complexCalculation(input));
}
`Isolate.run()`（または `compute()` 関数）は、指定した関数を新しい Isolate で実行し、その結果をメインスレッドに返してくれる便利なユーティリティだ。これにより、UI のフリーズを防ぎ、アプリケーション全体の応答性を維持することができる。
結論：数値型との向き合い方
Dart の数値型は、その柔軟性とパフォーマンスのバランスが取れている。`var`, `final`, `const` の適切な使い分け、`int` と `double` の特性理解、そして `num` 型の利用における注意点を押さえることで、堅牢で効率的なコードを書くことができる。
特に、クロスプラットフォーム開発や、数値計算の精度が critical となるようなセキュリティ関連のロジックを実装する際には、プラットフォームごとの挙動の違い（特に JavaScript 環境での `int` の精度）や、浮動小数点演算の誤差について深く理解しておくことが不可欠だ。
これらの低レイヤの知識は、表層的なAPIの利用だけでは得られない、コードの挙動を深く理解し、潜在的なバグやパフォーマンスのボトルネックを未然に防ぐための強力な武器となる。真のエンジニアリングとは、このような細部に宿る真実を見抜く力から始まるのだ。