Rustという言語において、数値を扱う型は多岐にわたりますが、実数（小数点を含む数値）を扱う際に中心となるのがf32とf64です。

システムプログラミングにおいて、精度の確保と実行速度のバランスは常に重要な課題となります。

Rustは、IEEE 754標準に準拠した浮動小数点型を提供しており、開発者は用途に応じてこれらを使い分ける必要があります。

本記事では、f32とf64の基本的な違いから、演算時の注意点、さらにはパフォーマンス最適化の具体的な手法までを詳しく掘り下げていきます。

浮動小数点の特性を正しく理解することは、バグの少ない堅牢なアプリケーションを構築するための第一歩となるでしょう。

目次 [ close ]
  1. f32とf64の基本仕様と内部構造
    1. ビット構成の違い
    2. 精度と有効桁数
  2. 浮動小数点演算における誤差と注意点
    1. 0.1 + 0.2 が 0.3 にならない理由
    2. 比較演算でのマージンの利用
  3. 特殊な値（NaN, Infinity）の取り扱い
    1. NaN（非数）の性質
    2. PartialOrdとOrdの違い
  4. パフォーマンス最適化：f32とf64の使い分け
    1. メモリ帯域とキャッシュ効率
    2. SIMD（Single Instruction, Multiple Data）の活用
    3. 計算コストの比較
  5. 型変換（Casting）の安全性と挙動
    1. アップキャストとダウンキャスト
    2. 整数への変換
  6. 高精度な計算が必要な場合の代替案
    1. rust_decimalクレートの利用
    2. bigdecimalやnum-bigint
  7. 実用的なTipsと推奨ライブラリ
    1. 数学関数の呼び出し
    2. num-traitsによるジェネリックプログラミング
  8. まとめ

f32とf64の基本仕様と内部構造

Rustにおける浮動小数点型は、ビット数によってその精度とメモリ使用量が明確に定義されています。 f32は単精度（Single Precision）、f64は倍精度（Double Precision）と呼ばれます。

ビット構成の違い

浮動小数点は、符号部、指数部、仮数部の3つの要素で構成されています。

これら3つの構成要素に割り振られるビット数が、型の性質を決定づけます。

項目f32 (単精度)f64 (倍精度)
合計ビット数32ビット64ビット
符号部 (Sign)1ビット1ビット
指数部 (Exponent)8ビット11ビット
仮数部 (Fraction)23ビット52ビット

精度と有効桁数

f32の有効桁数は、十進法に換算すると約6〜9桁程度です。

一方で、f64は約15〜17桁という非常に高い精度を持っています。

Rustのデフォルトの浮動小数点型がf64である理由は、現代の64ビットCPUにおいて処理速度がf32と遜色なく、かつ計算誤差を抑えられるためです。

浮動小数点演算における誤差と注意点

コンピュータは数値を2進数で管理するため、10進数ではキリの良い数字でも内部的には無限小数になってしまうことがあります。

このセクションでは、実務で直面しやすい誤差の問題について解説します。

0.1 + 0.2 が 0.3 にならない理由

多くのプログラミング言語と同様に、Rustでも0.1 + 0.2 == 0.3はfalseを返します。

これはバグではなく、IEEE 754形式における表現の限界によるものです。

Rust
fn main() {
    let x: f64 = 0.1;
    let y: f64 = 0.2;
    let sum = x + y;

    println!("sum: {}", sum);
    println!("sum == 0.3: {}", sum == 0.3);
}
実行結果
sum: 0.30000000000000004
sum == 0.3: false

このように、わずかな端数が発生するため、浮動小数点同士を == 演算子で直接比較することは避けるべきです。

比較演算でのマージンの利用

数値を比較する際は、絶対値の差が非常に小さい値（エプシロン）以下であるかどうかを判定する方法が一般的です。

Rustの標準ライブラリには、それぞれの型に対してf32::EPSILONやf64::EPSILONが定義されています。

Rust
fn main() {
    let a: f64 = 0.1 + 0.2;
    let b: f64 = 0.3;

    // 差の絶対値がエプシロンより小さいかを確認
    if (a - b).abs() < f64::EPSILON {
        println!("ほぼ等しいとみなします");
    }
}

より厳密な比較が必要な場合は、外部クレートのapproxなどを使用すると便利です。

特殊な値（NaN, Infinity）の取り扱い

浮動小数点には、通常の数値以外にも特別な状態が存在します。

非数（NaN: Not a Number）や、無限大（Infinity）がこれに該当します。

NaN（非数）の性質

0.0 / 0.0や、負の数の平方根を計算しようとすると、結果はNaNになります。

重要な点は、NaNは自分自身を含め、いかなる数値とも等しくないという性質です。

Rust
fn main() {
    let x = f64::NAN;
    println!("x == x: {}", x == x); // falseになる
    
    // 安全なチェック方法
    if x.is_nan() {
        println!("これは数値ではありません");
    }
}

PartialOrdとOrdの違い

Rustのf32やf64は、PartialOrdトレイトを実装していますが、Ordトレイトは実装していません。

これは、前述のNaNの存在により、全ての数値の間に全順序関係を定義できないためです。

そのため、浮動小数点の配列をsort()メソッドで直接ソートすることはできず、sort_by や partial_cmp を使用する必要があります。

Rust
fn main() {
    let mut values = [1.5, f64::NAN, 0.5];
    
    // 直接 sort() は呼べないため、unwrapなどで対応する
    values.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
    
    println!("{:?}", values);
}

パフォーマンス最適化：f32とf64の使い分け

実行速度やメモリ効率を追求する場合、どちらの型を選択すべきかは重要な戦略となります。

単に「精度が高いからf64」という選択が常に正しいわけではありません。

メモリ帯域とキャッシュ効率

f32はf64の半分のメモリサイズ（4バイト）しか消費しません。

大規模な配列や行列計算を行う場合、f32を選択することでメモリ使用量を半分に抑えることができます。

これは単にメモリを節約するだけでなく、CPUキャッシュへの適合率（キャッシュヒット率）を高めることにつながります。

多くのデータを一度に処理するグラフィックス演算や機械学習の推論フェーズでは、f32が好んで使われる傾向にあります。

SIMD（Single Instruction, Multiple Data）の活用

現代のプロセッサは、1つの命令で複数のデータを同時に処理するSIMD命令セットを持っています。

32ビットのf32を使用すれば、同じレジスタ幅（例えば256ビットのAVXレジスタ）の中に、f64の2倍の個数の数値を詰め込むことができます。

これにより、理論上のスループットを2倍に向上させることが可能です。 Rustではstd::simd（nightly）や、packed_simdクレートを通じてこれらの機能を活用できます。

計算コストの比較

多くのx86_64アーキテクチャのCPUでは、スカラー計算におけるf32とf64の演算レイテンシはほぼ同じです。

しかし、除算（割り算）や平方根の計算においては、精度の低いf32の方がわずかに高速に動作する場合があります。

厳密な速度が求められる物理シミュレーションなどでは、これらのマイクロベンチマークが重要になります。

型変換（Casting）の安全性と挙動

Rustにおいて異なる型同士の演算を行うには、明示的な型変換が必要です。

数値型を変換する際には、asキーワードを使用するのが一般的です。

アップキャストとダウンキャスト

f32からf64への変換（アップキャスト）は、精度が失われないため安全に行うことができます。

一方で、f64からf32への変換（ダウンキャスト）は、収まりきらない値が無限大（Infinity）になったり、精度が切り捨てられたりするリスクがあります。

Rust
fn main() {
    let big_val: f64 = 1.0e100;
    let small_val: f32 = big_val as f32;

    println!("f64: {}", big_val);
    println!("f32: {}", small_val); // 無限大になる
}
実行結果
f64: 1e100
f32: inf

整数への変換

浮動小数点を整数に変換する場合、小数点以下は切り捨てられます。

また、対象の整数型の範囲を超えている場合は、その整数型の最大値または最小値に飽和（サチュレーション）されます。

変換後の値が意図した範囲内にあるかを事前に確認することが、ランタイムエラーを防ぐ鍵となります。

高精度な計算が必要な場合の代替案

金融システムの開発や、天文学的な計算など、浮動小数点の誤差が許容されないケースがあります。

そのような場合、Rustの標準の浮動小数点型以外の選択肢を検討すべきです。

rust_decimalクレートの利用

金融計算には、10進数ベースで計算を行うrust_decimalクレートが推奨されます。

このクレートが提供するDecimal型は、内部的に10進数をベースとした表現を使用するため、0.1 + 0.2が正確に0.3になります。

bigdecimalやnum-bigint

任意精度の計算が必要な場合は、bigdecimalクレートを使用することで、メモリが許す限りの精度を確保できます。

ただし、これらのライブラリは標準のf32やf64に比べて計算速度が大幅に低下するため、パフォーマンスとのトレードオフになります。

実用的なTipsと推奨ライブラリ

最後に、Rustで浮動小数点を扱う際に知っておくと便利なテクニックを紹介します。

数学関数の呼び出し

Rustの浮動小数点型には、多くの数学メソッドが組み込まれています。

例えば、powf（累乗）、sqrt（平方根）、sin、cos、ln（自然対数）などが、f32/f64型のメソッドとして直接呼び出せます。

Rust
fn main() {
    let x: f64 = 2.0;
    let root = x.sqrt();
    let power = x.powf(3.0);
    
    println!("sqrt: {}, power: {}", root, power);
}

num-traitsによるジェネリックプログラミング

f32とf64の両方に対応した共通の関数を書きたい場合、num-traitsクレートのFloatトレイトを利用すると便利です。

これにより、特定の型に依存しない数値計算ロジックを共通化できます。

まとめ

Rustにおけるf32とf64の使い分けは、精度の必要性とリソースの制約という2つの軸で判断されます。

一般的なアプリケーション開発においては、デフォルトで f64 を選択するのが最も安全なアプローチです。 しかし、大量のデータを扱うグラフィックスや科学計算、あるいは組み込み環境のようなメモリ制約が厳しい場面では、f32の持つメモリ効率とSIMDによる高速化のメリットが際立ちます。

浮動小数点特有の誤差や、NaNの挙動といった性質を正しく理解し、適切に比較演算や型変換を行うことで、Rustの持つ安全性を最大限に活かした数値処理が可能になります。

また、もし厳密な10進数計算が必要な場合には、迷わず専用のライブラリ（クレート）を導入することを検討してください。

これらの知識をマスターすることで、精度の高い、そして高速なRustプログラムを自信を持って構築できるようになるはずです。