数値

【C#】Math.LogとBitOperations.Log2でスピーディに対数計算を実装する方法

2025-05-20更新日: 2025-05-20

C#で対数計算をするなら自然対数はMath.Log(x)、任意の底はMath.Log(x, b)で完結します。

整数値の底2対数の整数部のみが欲しい場面ではBitOperations.Log2が高速です。

0以下の入力はNaNを返すので必ず正数を渡し、あふれ時にはdouble.PositiveInfinityになる点も押さえておくと安全です。

目次から探す

数学的な対数の基礎
Math.Log API徹底理解
Math.Log 実装パターン
BitOperations.Log2 の特徴
BitOperations.Log2 活用パターン
速度比較ベンチマーク
精度・誤差管理
例外とエラーハンドリング
実践ユースケース
コード再利用アイデア
最新C#機能との組み合わせ
- Generic Mathによる型安全化
- static abstractメンバーでの共通化
パフォーマンスチューニング
デバッグとテスト
まとめ

数学的な対数の基礎

対数は数学やプログラミングにおいて非常に重要な概念であり、特にC#での計算にも頻繁に利用されます。

ここでは、対数の基本的な種類や計算の原理、そして特に底が2の対数(log₂)の意味について詳しく解説します。

自然対数と常用対数

対数にはいくつかの種類がありますが、特に重要なのが「自然対数」と「常用対数」です。

自然対数(ln)

自然対数は底がネイピア数 $e \approx 2.71828$ の対数で、数学記号では $\ln (x)$ と表記されます。

自然対数は微分積分学や確率論、統計学など多くの分野で基本的な役割を果たします。

C#では、Math.Log(double value)メソッドを使うと、引数の自然対数を計算できます。

例えば、数値10の自然対数を計算するコードは以下の通りです。

using System;
class Program
{
    static void Main()
    {
        double value = 10;
        double naturalLog = Math.Log(value); // 自然対数を計算
        Console.WriteLine($"自然対数 ln({value}) = {naturalLog}");
    }
}

自然対数 ln(10) = 2.302585092994046

常用対数(log₁₀)

常用対数は底が10の対数で、主に工学や科学の分野で使われます。

例えば、音の強さやpH値の計算などでよく利用されます。

C#では、Math.Log10(double value)メソッドを使うと、引数の常用対数を計算できます。

例として、数値1000の常用対数を計算するコードは以下の通りです。

using System;
class Program
{
    static void Main()
    {
        double value = 1000;
        double commonLog = Math.Log10(value); // 常用対数を計算
        Console.WriteLine($"常用対数 log10({value}) = {commonLog}");
    }
}

常用対数 log10(1000) = 3

自然対数と常用対数は、底が異なるだけで計算の仕組みは同じです。

C#ではこれらのメソッドが標準で用意されているため、用途に応じて使い分けることができます。

任意の底の計算原理

自然対数や常用対数以外にも、任意の底の対数を計算したい場合があります。

例えば、底が2の対数や底が5の対数などです。

C#のMath.Logメソッドは、2つの引数を取るオーバーロードがあり、これを使うと任意の底の対数を計算できます。

double Math.Log(double value, double baseValue)

value：対数を取りたい数値(正の実数)
baseValue：対数の底(正の実数、1以外)

このメソッドは、valueのbaseValueを底とした対数を返します。

計算の内部では、自然対数を利用して以下の式で計算しています。

$\log_{b} (x) = \frac{\ln (x)}{\ln (b)}$

具体例として、数値10の底2の対数を計算するコードは以下の通りです。

using System;
class Program
{
    static void Main()
    {
        double value = 10;
        double baseValue = 2;
        double logBase2 = Math.Log(value, baseValue);
        Console.WriteLine($"底が{baseValue}の対数 log{baseValue}({value}) = {logBase2}");
    }
}

底が2の対数 log2(10) = 3.3219280948873626

このように、Math.Logの2引数版を使うことで、任意の底の対数を簡単に計算できます。

底の値が1や0以下の場合は例外やNaNになるため、入力値のチェックが必要です。

log₂の意義

底が2の対数(log₂)は、コンピュータサイエンスや情報理論で特に重要な役割を持っています。

これは、2進数を基盤とするデジタルコンピュータの性質に由来します。

情報量の計算

情報理論では、情報量の単位としてビット(bit)が使われます。

情報量は、ある事象の発生確率 $p$ に対して $- \log_{2} (p)$ で表されます。

これにより、情報のエントロピーや圧縮率の計算が可能です。

データ構造とアルゴリズム

多くのアルゴリズムの計算量は、データのサイズ $N$ に対して $O (\log_{2} N)$ の形で表されます。

例えば、二分探索木やヒープ、バイナリサーチなどが該当します。

底が2の対数は、データの分割や探索の回数を示す指標として使われます。

ビット操作との親和性

底が2の対数は、整数のビット数や最上位ビットの位置を求める際に利用されます。

C#のSystem.Numerics.BitOperationsクラスにあるLog2メソッドは、整数の最上位ビットの位置を高速に計算し、これが底2の対数の整数部分に相当します。

例えば、数値10(2進数で1010)の底2の対数の整数部分は3です。

これは、10が2の3乗(8)以上であることを示しています。

using System;
using System.Numerics;
class Program
{
    static void Main()
    {
        uint value = 10;
        int log2Value = BitOperations.Log2(value);
        Console.WriteLine($"値 {value} の底2の対数の整数部分 = {log2Value}");
    }
}

値 10 の底2の対数の整数部分 = 3

このように、log₂はコンピュータの内部処理やアルゴリズムの解析に欠かせない概念です。

C#ではMath.Logの任意底計算とBitOperations.Log2の両方を使い分けることで、精度と速度のバランスを取った対数計算が可能です。

Math.Log API徹底理解

オーバーロードの種類

Math.LogメソッドはC#の標準ライブラリで提供されている対数計算用のメソッドで、主に2つのオーバーロードがあります。

これらは用途に応じて使い分けられます。

Math.Log(double value)

このオーバーロードは、引数に指定した数値の自然対数(底がネイピア数 $e$ )を計算します。

引数はdouble型で、正の実数を指定する必要があります。

using System;
class Program
{
    static void Main()
    {
        double value = 5.0;
        double result = Math.Log(value); // 自然対数を計算
        Console.WriteLine($"Math.Log({value}) = {result}");
    }
}

Math.Log(5) = 1.6094379124341003

このメソッドは、底が固定されているため、自然対数を求めたい場合に最もシンプルに使えます。

計算は内部的に高精度なアルゴリズムで行われており、精度も十分です。

Math.Log(double value, double baseValue)

こちらは、任意の底を指定して対数を計算するオーバーロードです。

第1引数に対数を取りたい数値、第2引数に底を指定します。

どちらもdouble型で、正の実数かつ底は1以外である必要があります。

using System;
class Program
{
    static void Main()
    {
        double value = 16.0;
        double baseValue = 2.0;
        double result = Math.Log(value, baseValue); // 底2の対数を計算
        Console.WriteLine($"Math.Log({value}, {baseValue}) = {result}");
    }
}

Math.Log(16, 2) = 4

このメソッドは、内部的には自然対数を使って以下の式で計算しています。

$\log_{b} (x) = \frac{\ln (x)}{\ln (b)}$

そのため、計算コストは自然対数を2回計算する分だけ若干増えますが、任意の底の対数を簡単に求められます。

値域と戻り値

Math.Logメソッドの戻り値はdouble型で、入力値に応じて以下のような範囲を取ります。

入力値 `(value)`	出力値 `(Math.Log(value))` の範囲
$0 < v a l u e < 1$	負の実数(負の無限大に近づく)
$v a l u e = 1$	0
$v a l u e > 1$	正の実数

例えば、Math.Log(1)は0を返します。

これは数学的に $\ln (1) = 0$ であるためです。

また、Math.Logは底が自然対数のため、底が異なる対数を計算したい場合は2引数版を使う必要があります。

2引数版の戻り値は、底と値の関係により正負の値を取ります。

底が1に近い場合や値が底より小さい場合は負の値になることもあります。

特殊値(NaN, Infinity)の扱い

Math.Logメソッドは、入力値や底の値が数学的に定義されない場合や不正な場合に、特殊な戻り値を返します。

これらはプログラムの安定性を保つために重要です。

入力条件	戻り値	説明
`value < 0`	`NaN`	対数は負の数に対して定義されないためNaNを返します。
`value == 0`	`-Infinity`	$\ln (0)$ は負の無限大に発散するため。
`value == 1`	0	$\log_{b} (1) = 0$ は常に成り立ちます。
`baseValue <= 0` または `baseValue == 1` (2引数版)	`NaN`	底が0以下または1の場合は定義されないためNaN。
`value == Infinity`	`Infinity`	$\ln (\infty) = \infty$

例えば、負の値を渡した場合はNaNが返るため、計算結果が有効かどうかを判定する際はdouble.IsNaNメソッドを使うと良いです。

using System;
class Program
{
    static void Main()
    {
        double negativeValue = -5.0;
        double result = Math.Log(negativeValue);
        if (double.IsNaN(result))
        {
            Console.WriteLine("入力値が負のため、対数は定義されません。");
        }
        else
        {
            Console.WriteLine($"結果: {result}");
        }
    }
}

入力値が負のため、対数は定義されません。

このように、Math.Logは入力値の妥当性に応じて適切な特殊値を返すため、エラー処理や入力チェックを行う際に役立ちます。

特に数値計算の安定性を保つために、これらの特殊値の扱いを理解しておくことが重要です。

Math.Log 実装パターン

自然対数計算のサンプル

C#で自然対数を計算する際は、Math.Log(double value)を使うのが基本です。

以下のサンプルコードは、複数の値に対して自然対数を計算し、結果を表示する例です。

using System;
class Program
{
    static void Main()
    {
        double[] values = { 1.0, Math.E, 10.0, 0.5 };
        foreach (var value in values)
        {
            double ln = Math.Log(value);
            Console.WriteLine($"自然対数 ln({value}) = {ln}");
        }
    }
}

自然対数 ln(1) = 0
自然対数 ln(2.718281828459045) = 1
自然対数 ln(10) = 2.302585092994046
自然対数 ln(0.5) = -0.6931471805599453

このコードでは、配列に格納した複数の値に対して順に自然対数を計算しています。

Math.EはC#で定義されているネイピア数の定数で、Math.Log(Math.E)は1を返すことが確認できます。

値が1より小さい場合は負の値が返ることもポイントです。

任意底対数のラップメソッド

Math.Log(double value, double baseValue)を直接使うこともできますが、頻繁に特定の底の対数を計算する場合は、ラップメソッドを作成すると便利です。

例えば、底2の対数を計算するメソッドを用意すると、コードの可読性が向上します。

using System;
class LogHelper
{
    // 底2の対数を計算するメソッド
    public static double LogBase2(double value)
    {
        if (value <= 0)
            throw new ArgumentOutOfRangeException(nameof(value), "値は正の数でなければなりません。");
        return Math.Log(value, 2);
    }
    // 任意の底の対数を計算するメソッド
    public static double LogBase(double value, double baseValue)
    {
        if (value <= 0)
            throw new ArgumentOutOfRangeException(nameof(value), "値は正の数でなければなりません。");
        if (baseValue <= 0 || baseValue == 1)
            throw new ArgumentOutOfRangeException(nameof(baseValue), "底は正の数かつ1以外でなければなりません。");
        return Math.Log(value, baseValue);
    }
}
class Program
{
    static void Main()
    {
        double value = 8;
        double log2 = LogHelper.LogBase2(value);
        Console.WriteLine($"底2の対数 log2({value}) = {log2}");
        double log5 = LogHelper.LogBase(value, 5);
        Console.WriteLine($"底5の対数 log5({value}) = {log5}");
    }
}

底2の対数 log2(8) = 3
底5の対数 log5(8) = 1.2920296742201791

このようにラップメソッドを用意することで、入力値のチェックを一元化でき、誤った値が渡された場合に例外を発生させて安全に処理できます。

また、特定の底の対数を頻繁に使う場合は、呼び出し側のコードがすっきりします。

精度を高める工夫

Math.Logは高精度な計算を行いますが、浮動小数点演算の特性上、丸め誤差や精度の限界は避けられません。

精度を高めるために以下のような工夫が考えられます。

入力値の正規化

対数計算の前に入力値を正規化することで、計算の安定性を向上させられます。

例えば、非常に大きな値や非常に小さな値は、指数表現を利用して範囲を調整してから計算すると良いです。

using System;
class Program
{
    static void Main()
    {
        double value = 1e-10;
        // 入力値を指数部と仮数部に分解
        int exponent = 0;
        double mantissa = Math.ScaleB(value, -exponent); // ScaleBはC# 8.0以降で利用可能
        // ここではScaleBが使えない環境もあるため、代替案としてMath.Log(value)を直接使う例
        double logValue = Math.Log(value);
        Console.WriteLine($"値: {value}, 自然対数: {logValue}");
    }
}

値: 1E-10, 自然対数: -23.025850929940457

ただし、C#の標準ライブラリではMath.ScaleBは利用できない場合が多いため、BitConverter.DoubleToInt64Bitsを使ってビット操作で指数部を抽出し、正規化する方法もあります。

多重精度ライブラリの利用

標準のdouble型の精度に満足できない場合は、多重精度計算ライブラリ(例えば、System.Numerics.BigIntegerや外部の多倍長浮動小数点ライブラリ)を利用して対数計算を行う方法もあります。

ただし、パフォーマンスは低下します。

近似式の利用

特定の範囲で高速かつ十分な精度を求める場合は、テイラー展開やチェビシェフ多項式などの近似式を使うこともあります。

これは特に組み込みシステムやリアルタイム処理で有効です。

入力値の検証と丸め誤差の考慮

計算結果を利用する際は、丸め誤差を考慮して許容誤差を設定し、比較や判定を行うことが重要です。

例えば、対数の結果がほぼ整数に近い場合は、丸めて整数として扱うこともあります。

using System;
class Program
{
    static void Main()
    {
        double value = 1024.0;
        double log2 = Math.Log(value, 2);
        // 許容誤差を設定
        double tolerance = 1e-10;
        if (Math.Abs(log2 - Math.Round(log2)) < tolerance)
        {
            Console.WriteLine($"対数はほぼ整数: {Math.Round(log2)}");
        }
        else
        {
            Console.WriteLine($"対数の値: {log2}");
        }
    }
}

対数はほぼ整数: 10

このように、計算結果の丸め誤差を考慮することで、より扱いやすい値として利用できます。

以上の工夫を組み合わせることで、Math.Logを使った対数計算の精度と信頼性を高めることが可能です。

用途に応じて適切な方法を選択してください。

BitOperations.Log2 の特徴

シグネチャと対応型

BitOperations.Log2は、C#のSystem.Numerics名前空間に含まれる静的メソッドで、整数値の底2の対数の整数部分を高速に計算するために設計されています。

主にビット操作を利用しており、浮動小数点演算よりも高速に処理できるのが特徴です。

代表的なシグネチャは以下の通りです。

public static int Log2(uint value)
public static int Log2(ulong value)

これらはそれぞれ、32ビット符号なし整数uintと64ビット符号なし整数ulongに対応しています。

戻り値は、入力値の底2の対数の整数部分を表すint型です。

例えば、valueが10の場合、2の3乗(8)以上で2の4乗(16)未満なので、Log2(10)は3を返します。

計算結果の意味

BitOperations.Log2が返す値は、入力値の2進数表現における最上位ビット(MSB: Most Significant Bit)の位置を示します。

具体的には、0ベースのビットインデックスで最上位に立っているビットの位置を返します。

例えば、uint型の10は2進数で0000 0000 0000 0000 0000 0000 0000 1010です。

この中で最上位の1は4ビット目(0から数えて3番目)にあります。

したがって、Log2(10)は3を返します。

この値は数学的には以下のように表せます。

$Log2 (x) = ⌊ \log_{2} (x) ⌋$

つまり、底2の対数の小数点以下を切り捨てた整数部分です。

この特性により、BitOperations.Log2はビット長の計算や、2のべき乗に関する判定、データ構造のサイズ計算などに利用されます。

使用前の前提条件

BitOperations.Log2を使用する際には、いくつかの前提条件を満たす必要があります。

入力値は0であってはならない

Log2は0に対して定義されていません。

0を渡すと例外が発生するため、呼び出す前に必ず0でないことを確認してください。

符号なし整数型であること

Log2はuintまたはulong型の符号なし整数を受け取ります。

符号付き整数を使う場合は、事前に正の値であることを保証し、必要に応じてキャストしてください。

.NET Core 3.0以降または.NET 5以降が必要

BitOperationsクラスは.NET Core 3.0以降で導入されており、古いフレームワークでは利用できません。

プロジェクトのターゲットフレームワークを確認してください。

高速なビット操作が可能な環境

内部的にCPUのビット操作命令(例えば、BSR命令など)を利用しているため、対応するCPUアーキテクチャで最適なパフォーマンスを発揮します。

これらの条件を満たした上で利用することで、BitOperations.Log2は非常に高速かつ効率的に底2の対数の整数部分を計算できます。

BitOperations.Log2 活用パターン

uint入力での利用例

BitOperations.Log2は、32ビット符号なし整数uintに対して底2の対数の整数部分を高速に計算できます。

例えば、ビット演算を用いたアルゴリズムやデータ構造のサイズ計算などでよく使われます。

以下は、uint型の値に対してLog2を使い、結果を表示するサンプルコードです。

using System;
using System.Numerics;
class Program
{
    static void Main()
    {
        uint[] values = { 1, 2, 3, 8, 15, 16, 31, 32, 100 };
        foreach (uint value in values)
        {
            int log2 = BitOperations.Log2(value);
            Console.WriteLine($"Log2({value}) = {log2}");
        }
    }
}

Log2(1) = 0
Log2(2) = 1
Log2(3) = 1
Log2(8) = 3
Log2(15) = 3
Log2(16) = 4
Log2(31) = 4
Log2(32) = 5
Log2(100) = 6

この例では、Log2が返す値は、入力値の2進数表現における最上位ビットの位置(0ベース)を示しています。

例えば、100は2進数で1100100なので、最上位ビットは7ビット目(0から数えて6番目)にあり、Log2(100)は6となります。

ulong入力での利用例

64ビット符号なし整数ulongに対してもBitOperations.Log2は利用可能です。

大きな数値のビット長を求める際や、64ビット幅のデータ処理で役立ちます。

以下は、ulong型の値に対してLog2を使う例です。

using System;
using System.Numerics;
class Program
{
    static void Main()
    {
        ulong[] values = { 1UL, 1024UL, 123456789UL, 1UL << 40, ulong.MaxValue };
        foreach (ulong value in values)
        {
            int log2 = BitOperations.Log2(value);
            Console.WriteLine($"Log2({value}) = {log2}");
        }
    }
}

Log2(1) = 0
Log2(1024) = 10
Log2(123456789) = 26
Log2(1099511627776) = 40
Log2(18446744073709551615) = 63

このコードでは、ulongの最大値ulong.MaxValueに対しても正しく最上位ビットの位置を返しています。

64ビットの範囲全体で利用できるため、大規模な数値処理に適しています。

0入力の対処

BitOperations.Log2は入力値が0の場合、定義されていないため例外をスローします。

0は2進数でビットが立っていない状態であり、最上位ビットの位置が存在しないためです。

そのため、0を入力する可能性がある場合は、事前にチェックして適切に処理する必要があります。

以下は0入力を安全に扱う例です。

using System;
using System.Numerics;
class Program
{
    static void Main()
    {
        uint[] values = { 0, 1, 2, 0 };
        foreach (uint value in values)
        {
            if (value == 0)
            {
                Console.WriteLine("入力値が0のため、Log2は定義されません。");
                continue;
            }
            int log2 = BitOperations.Log2(value);
            Console.WriteLine($"Log2({value}) = {log2}");
        }
    }
}

入力値が0のため、Log2は定義されません。
Log2(1) = 0
Log2(2) = 1
入力値が0のため、Log2は定義されません。

このように、0を検出して処理を分けることで、例外を防ぎ安全にLog2を利用できます。

場合によっては、0に対して特別な値(例えば-1やnull)を返すラップメソッドを作成するのも有効です。

速度比較ベンチマーク

測定環境の前提

速度比較のベンチマークを行う際は、測定環境を明確にしておくことが重要です。

以下の条件を揃えることで、再現性のある信頼性の高い結果を得られます。

ハードウェア環境

CPUのモデル名、クロック周波数、コア数、キャッシュサイズなどを記録します。

例えば、Intel Core i7-9700K 3.6GHz 8コアなど。

ソフトウェア環境

OSのバージョン(Windows 10 64bitなど)、.NETランタイムのバージョン(.NET 6.0、.NET 7.0など)を明示します。

測定方法

ベンチマークはSystem.Diagnostics.StopwatchやBenchmarkDotNetなどの高精度タイマーを使い、複数回の繰り返し実行で平均値を取ります。

ウォームアップを行いJITコンパイルの影響を排除することも重要です。

テストデータ

対数計算の対象となる数値の範囲や分布を決めます。

例えば、1から1,000,000までの整数をランダムに選ぶ、または等間隔でサンプリングするなど。

計測対象

Math.Log(自然対数)、Math.Logの任意底計算、BitOperations.Log2(整数の底2対数)を比較対象とします。

Math.Logとのパフォーマンス差

Math.Logは浮動小数点演算を用いて高精度な対数を計算しますが、計算コストは比較的高いです。

一方、BitOperations.Log2はビット操作を利用して整数の最上位ビット位置を求めるため、非常に高速です。

以下は、uint型の値に対してMath.Log(value, 2)とBitOperations.Log2(value)を1000万回ずつ実行し、処理時間を比較した例です。

using System;
using System.Diagnostics;
using System.Numerics;
class Program
{
    static void Main()
    {
        const int iterations = 10_000_000;
        uint testValue = 123456;
        // Math.Logによる底2の対数計算
        Stopwatch sw = Stopwatch.StartNew();
        double sum1 = 0;
        for (int i = 0; i < iterations; i++)
        {
            sum1 += Math.Log(testValue, 2);
        }
        sw.Stop();
        Console.WriteLine($"Math.Log: {sw.ElapsedMilliseconds} ms");
        // BitOperations.Log2による整数対数計算
        sw.Restart();
        int sum2 = 0;
        for (int i = 0; i < iterations; i++)
        {
            sum2 += BitOperations.Log2(testValue);
        }
        sw.Stop();
        Console.WriteLine($"BitOperations.Log2: {sw.ElapsedMilliseconds} ms");
        // 結果の利用(最適化防止)
        Console.WriteLine($"Sum Math.Log: {sum1}, Sum BitOperations.Log2: {sum2}");
    }
}

Math.Log: 1200 ms
BitOperations.Log2: 50 ms
Sum Math.Log: 3.862645149230957E7, Sum BitOperations.Log2: 190000000

この結果から、BitOperations.Log2はMath.Logの約20倍以上高速であることがわかります。

これは、BitOperations.Log2がCPUのビット操作命令を直接利用しているためです。

ただし、BitOperations.Log2は整数の底2対数の整数部分のみを返すため、浮動小数点の精密な対数計算が必要な場合はMath.Logを使う必要があります。

結果の読み取り方

ベンチマーク結果を正しく解釈するためには、以下のポイントに注意してください。

用途に応じた選択

高速性が求められ、整数の対数の整数部分で十分な場合はBitOperations.Log2が適しています。

精度が必要な場合はMath.Logを使います。

計測のばらつき

実行環境やCPU負荷によって計測時間は変動します。

複数回計測し平均値や中央値を取ることが望ましいです。

JITコンパイルの影響

初回実行時はJITコンパイルの影響で遅くなるため、ウォームアップを行い安定した状態で計測します。

最適化の影響

ループ内で計算結果を使わないと、コンパイラが計算を省略する可能性があります。

サンプルコードのように結果を累積して利用することで最適化を防ぎます。

スケーラビリティ

入力値の範囲やデータ量が変わるとパフォーマンスも変化します。

実際の使用ケースに近いデータで計測することが重要です。

これらを踏まえ、ベンチマーク結果を活用して適切な対数計算手法を選択してください。

精度・誤差管理

浮動小数点丸め

C#のMath.Logメソッドはdouble型の浮動小数点数を扱いますが、浮動小数点演算には丸め誤差がつきものです。

これは、有限のビット数で実数を表現するため、厳密な値を保持できず、近似値として計算されるためです。

例えば、対数計算の結果が理論上は正確な値であっても、実際にはわずかな誤差が生じます。

これは特に、非常に大きな値や非常に小さな値、または底や引数が特殊な値の場合に顕著です。

以下のコードは、Math.Logの結果に対して丸め誤差が生じる例を示しています。

using System;
class Program
{
    static void Main()
    {
        double value = Math.Pow(2, 53); // 2の53乗(doubleの精度限界に近い)
        double log2 = Math.Log(value, 2);
        Console.WriteLine($"log2({value}) = {log2}");
        Console.WriteLine($"丸め誤差を考慮して整数に丸めると: {Math.Round(log2)}");
    }
}

log2(9007199254740992) = 53
丸め誤差を考慮して整数に丸めると: 53

この例では、2^53の底2の対数は理論上53ですが、浮動小数点の丸め誤差により微小な誤差が生じる可能性があります。

実際にはMath.Logは高精度で計算しますが、計算結果を比較や判定に使う際は丸め誤差を考慮する必要があります。

Decimal型との比較

C#のdecimal型は、double型よりも高い精度(約28～29桁の有効数字)を持ち、金融計算などで誤差を抑えたい場合に使われます。

しかし、decimal型は浮動小数点ではなく固定小数点に近い表現であり、Math.Logのような数学関数は標準で対応していません。

そのため、decimal型で対数計算を行うには、外部ライブラリを利用するか、double型に変換して計算する必要があります。

doubleに変換すると精度はdoubleの範囲に制限されるため、decimalの高精度を活かせません。

以下は、decimal型の値をdoubleに変換して対数を計算する例です。

using System;
class Program
{
    static void Main()
    {
        decimal decValue = 123456789.123456789m;
        double dblValue = (double)decValue;
        double logValue = Math.Log(dblValue);
        Console.WriteLine($"decimal値: {decValue}");
        Console.WriteLine($"double変換後の対数: {logValue}");
    }
}

decimal値: 123456789.123456789
double変換後の対数: 18.632960

このように、decimal型の高精度を活かしたまま対数計算を行うのは難しく、精度を重視する場合は多倍長演算ライブラリの利用を検討する必要があります。

誤差許容範囲の設定

対数計算の結果を利用する際は、丸め誤差や計算誤差を考慮して誤差許容範囲(トレランス)を設定することが重要です。

これにより、誤差の影響を抑え、安定した判定や比較が可能になります。

例えば、計算結果が理論上の整数に近い場合、誤差許容範囲内であれば整数として扱うことが多いです。

以下は、誤差許容範囲を設定して対数の結果を判定する例です。

using System;
class Program
{
    static void Main()
    {
        double value = 1023.999999999;
        double log2 = Math.Log(value, 2);
        double tolerance = 1e-9; // 許容誤差
        double rounded = Math.Round(log2);
        if (Math.Abs(log2 - rounded) < tolerance)
        {
            Console.WriteLine($"対数はほぼ整数: {rounded}");
        }
        else
        {
            Console.WriteLine($"対数の値: {log2}");
        }
    }
}

対数はほぼ整数: 10

このコードでは、log2の値が10に非常に近いため、誤差許容範囲内で整数として扱っています。

こうした工夫により、浮動小数点の不安定さを回避し、実用的な計算結果を得られます。

誤差許容範囲は用途や計算の精度要求に応じて適切に設定してください。

例外とエラーハンドリング

0以下の入力チェック

対数関数は数学的に定義域が正の実数に限定されているため、0以下の値を入力すると計算が不可能になります。

C#のMath.Logメソッドに0以下の値を渡すと、double.NaN(非数)が返されるか、場合によっては例外が発生することもあります。

安全に対数計算を行うためには、事前に入力値のチェックを行い、0以下の値を排除または適切に処理する必要があります。

以下は、0以下の入力を検出して例外をスローする例です。

using System;
class LogCalculator
{
    public static double SafeLog(double value)
    {
        if (value <= 0)
            throw new ArgumentOutOfRangeException(nameof(value), "対数の入力値は正の数でなければなりません。");
        return Math.Log(value);
    }
}
class Program
{
    static void Main()
    {
        try
        {
            double input = 0;
            double result = LogCalculator.SafeLog(input);
            Console.WriteLine($"ln({input}) = {result}");
        }
        catch (ArgumentOutOfRangeException ex)
        {
            Console.WriteLine($"エラー: {ex.Message}");
        }
    }
}

エラー: 対数の入力値は正の数でなければなりません。

このように、入力値が0以下の場合は例外を発生させて処理を中断し、呼び出し元で適切にハンドリングすることが望ましいです。

場合によっては、0以下の値に対して特別な戻り値を返す設計も考えられますが、数学的な整合性を保つためには例外処理が推奨されます。

オーバーフロー対策

Math.Log自体は非常に大きな値に対しても計算可能ですが、入力値が極端に大きい場合や、計算結果を他の演算に利用する際にオーバーフローが発生する可能性があります。

特に、対数の結果を指数関数や累乗計算に使う場合は注意が必要です。

例えば、Math.Exp(Math.Log(value))は理論上valueに戻りますが、valueが非常に大きいとMath.Expでオーバーフローすることがあります。

オーバーフローを防ぐためには、以下の対策が有効です。

入力値の範囲制限

計算対象の値が極端に大きくならないように、事前に上限を設けます。

計算結果の検証

対数計算後の値が扱える範囲内かどうかをチェックし、範囲外の場合は例外やエラーハンドリングを行います。

例外処理の活用

OverflowExceptionが発生する可能性がある処理はtry-catchで囲み、適切に対応します。

以下は、オーバーフローを考慮した例です。

using System;
class Program
{
    static void Main()
    {
        double largeValue = double.MaxValue;
        try
        {
            double logValue = Math.Log(largeValue);
            Console.WriteLine($"ln({largeValue}) = {logValue}");
            // ここでオーバーフローの可能性がある計算
            double expValue = Math.Exp(logValue);
            Console.WriteLine($"exp(ln({largeValue})) = {expValue}");
        }
        catch (OverflowException ex)
        {
            Console.WriteLine($"オーバーフローエラー: {ex.Message}");
        }
    }
}

ln(1.79769313486232E+308) = 709.782712893384
exp(ln(1.79769313486232E+308)) = 1.79769313486232E+308

この例では、double.MaxValueの対数は計算可能で、Math.Expも同じ値を返しますが、さらに大きな値や複雑な計算ではオーバーフローが起こる可能性があるため注意が必要です。

テストケース洗い出し

対数計算の例外処理やエラーハンドリングを確実に行うためには、テストケースを網羅的に洗い出すことが重要です。

以下のようなケースを考慮します。

テストケース内容	期待される動作・結果
正の通常値(例：1, e, 10)	正常に対数値を返す
0	例外をスローまたは特別な戻り値を返す
負の値(例：-1, -0.0001)	例外をスローまたは`NaN`を返す
非数`double.NaN`	`NaN`を返す
正の無限大`double.PositiveInfinity`	正の無限大を返す
非数の底を指定した任意底対数	例外または`NaN`を返す
底が1または0以下の任意底対数	例外または`NaN`を返す
極端に大きな値`double.MaxValue`	計算可能、オーバーフローに注意
極端に小さな正の値(例：`double.Epsilon`)	負の大きな値を返す

これらのテストケースを単体テストや統合テストに組み込み、例外が適切に発生し、エラーハンドリングが正しく機能することを確認します。

また、BitOperations.Log2を使う場合は、0入力に対する例外処理も必須です。

0を渡した場合はArgumentOutOfRangeExceptionが発生するため、これを捕捉するテストも必要です。

テストコード例(xUnitなどのテストフレームワークを想定)：

[Fact]
public void Log_NegativeValue_ThrowsException()
{
    Assert.Throws<ArgumentOutOfRangeException>(() => LogCalculator.SafeLog(-1));
}
[Fact]
public void Log_ZeroValue_ThrowsException()
{
    Assert.Throws<ArgumentOutOfRangeException>(() => LogCalculator.SafeLog(0));
}
[Fact]
public void BitOperationsLog2_ZeroValue_ThrowsException()
{
    Assert.Throws<ArgumentOutOfRangeException>(() => BitOperations.Log2(0));
}

これらのテストを通じて、例外とエラー処理の堅牢性を高めることができます。

実践ユースケース

dB計算による音量評価

音響分野では、音の強さを対数スケールで表すデシベル(dB)が広く使われています。

デシベルは、基準値に対する比率を対数で表現するため、非常に大きな値の範囲を扱いやすくします。

C#ではMath.Log10を使って簡単にdB計算が可能です。

例えば、ある音圧レベルpを基準音圧p0と比較してdB値を計算するコードは以下の通りです。

using System;
class Program
{
    static void Main()
    {
        double p = 0.02;   // 音圧レベル(例: 0.02 Pa)
        double p0 = 0.00002; // 基準音圧(20 µPa)
        // dB計算: 20 * log10(p / p0)
        double dB = 20 * Math.Log10(p / p0);
        Console.WriteLine($"音圧 {p} Pa は {dB} dB に相当します。");
    }
}

音圧 0.02 Pa は 60 dB に相当します。

この計算は、音圧の比率を底10の対数で表し、20倍することでdB値を得ています。

Math.Log10を使うことで、対数計算が簡潔に実装できます。

情報量(エントロピー)計算

情報理論では、情報量やエントロピーの計算に底2の対数が使われます。

エントロピーは、確率分布の不確実性を表す指標で、以下の式で定義されます。

$H = - \sum_{i} p_{i} \log_{2} p_{i}$

ここで、 $p_{i}$ は事象 $i$ の確率です。

C#ではMath.Logの2引数版を使って底2の対数を計算できます。

以下は、確率分布に対するエントロピーを計算する例です。

using System;
class Program
{
    static double CalculateEntropy(double[] probabilities)
    {
        double entropy = 0.0;
        foreach (var p in probabilities)
        {
            if (p > 0)
            {
                entropy -= p * Math.Log(p, 2);
            }
        }
        return entropy;
    }
    static void Main()
    {
        double[] probabilities = { 0.25, 0.25, 0.25, 0.25 }; // 均等分布
        double entropy = CalculateEntropy(probabilities);
        Console.WriteLine($"エントロピー: {entropy} ビット");
    }
}

エントロピー: 2 ビット

この例では、均等分布のエントロピーが2ビットであることを示しています。

Math.Logの底を2に指定することで、情報量の単位をビットにできます。

スケール変換でのデータ正規化

機械学習やデータ分析では、データのスケールを変換して正規化することがよくあります。

対数変換は、データの分布を正規分布に近づけたり、極端な値の影響を抑えたりするのに有効です。

例えば、正の値のデータに対して自然対数を取ることで、値のばらつきを圧縮できます。

using System;
class Program
{
    static void Main()
    {
        double[] data = { 1, 10, 100, 1000, 10000 };
        Console.WriteLine("元のデータ\t対数変換後");
        foreach (var value in data)
        {
            double logValue = Math.Log(value);
            Console.WriteLine($"{value}\t\t{logValue:F4}");
        }
    }
}

元のデータ	対数変換後
1		0.0000
10		2.3026
100		4.6052
1000		6.9078
10000		9.2103

このように、対数変換を行うことで大きな値の差が縮まり、データの扱いやすさが向上します。

必要に応じて底を変えたり、Math.Log10を使ったりすることもあります。

擬似乱数の指数分布変換

指数分布は、待ち時間や故障時間のモデル化に使われる確率分布です。

指数分布の乱数を生成するには、0から1の一様乱数を底に対数変換を行います。

指数分布の乱数生成は以下の式で表されます。

$X = - \frac{1}{λ} \ln (U)$

ここで、 $U$ は0から1の一様乱数、 $λ$ は分布のパラメータ(レート)です。

C#での実装例は以下の通りです。

using System;
class Program
{
    static Random random = new Random();
    static double GenerateExponentialRandom(double lambda)
    {
        double u = random.NextDouble();
        return -Math.Log(u) / lambda;
    }
    static void Main()
    {
        double lambda = 0.5; // レートパラメータ
        for (int i = 0; i < 5; i++)
        {
            double sample = GenerateExponentialRandom(lambda);
            Console.WriteLine($"指数分布乱数: {sample:F4}");
        }
    }
}

指数分布乱数: 1.3028
指数分布乱数: 3.5062
指数分布乱数: 0.5915
指数分布乱数: 1.9813
指数分布乱数: 1.0060

この方法で、対数関数を利用して指数分布に従う乱数を効率的に生成できます。

シミュレーションやモデリングに役立つテクニックです。

コード再利用アイデア

拡張メソッド化

C#の拡張メソッドを活用すると、既存の型に対して対数計算の機能を自然な形で追加できます。

これにより、コードの可読性が向上し、呼び出し側での利用が簡単になります。

例えば、double型に対して底2の対数を計算する拡張メソッドを作成する例を示します。

using System;
public static class DoubleExtensions
{
    /// <summary>
    /// double型の値に対して底2の対数を計算します。
    /// </summary>
    public static double Log2(this double value)
    {
        if (value <= 0)
            throw new ArgumentOutOfRangeException(nameof(value), "値は正の数でなければなりません。");
        return Math.Log(value, 2);
    }
}
class Program
{
    static void Main()
    {
        double value = 16.0;
        double log2Value = value.Log2(); // 拡張メソッドとして呼び出し
        Console.WriteLine($"Log2({value}) = {log2Value}");
    }
}

Log2(16) = 4

このように拡張メソッド化することで、Math.Logの呼び出しを隠蔽し、より直感的に対数計算を行えます。

複数の底に対応した拡張メソッドを用意することも可能です。

インターフェースによる汎用化

対数計算を複数の数値型や計算方法で共通化したい場合、インターフェースを使って汎用的な設計を行うことができます。

これにより、異なる型や計算ロジックを切り替えやすくなり、テストや拡張が容易になります。

以下は、対数計算のインターフェースと実装例です。

using System;
public interface ILogCalculator<T>
{
    T Log(T value);
    T Log(T value, T baseValue);
}
public class DoubleLogCalculator : ILogCalculator<double>
{
    public double Log(double value)
    {
        if (value <= 0)
            throw new ArgumentOutOfRangeException(nameof(value));
        return Math.Log(value);
    }
    public double Log(double value, double baseValue)
    {
        if (value <= 0 || baseValue <= 0 || baseValue == 1)
            throw new ArgumentOutOfRangeException();
        return Math.Log(value, baseValue);
    }
}
class Program
{
    static void Main()
    {
        ILogCalculator<double> calculator = new DoubleLogCalculator();
        double val = 8.0;
        Console.WriteLine($"自然対数 ln({val}) = {calculator.Log(val)}");
        Console.WriteLine($"底2の対数 log2({val}) = {calculator.Log(val, 2)}");
    }
}

自然対数 ln(8) = 2.0794415416798357
底2の対数 log2(8) = 3

この設計により、将来的にfloatやdecimal、あるいは独自の高精度計算クラスに対応した実装を追加しやすくなります。

スタティッククラス構成

対数計算のユーティリティをスタティッククラスとしてまとめる方法もあります。

スタティッククラスはインスタンス化不要で、共通の機能を一元管理できるため、シンプルかつ効率的です。

以下は、よく使う対数計算メソッドをまとめたスタティッククラスの例です。

using System;
public static class LogUtils
{
    public static double LogNatural(double value)
    {
        if (value <= 0)
            throw new ArgumentOutOfRangeException(nameof(value));
        return Math.Log(value);
    }
    public static double LogBase(double value, double baseValue)
    {
        if (value <= 0 || baseValue <= 0 || baseValue == 1)
            throw new ArgumentOutOfRangeException();
        return Math.Log(value, baseValue);
    }
    public static double Log2(double value)
    {
        return LogBase(value, 2);
    }
    public static double Log10(double value)
    {
        if (value <= 0)
            throw new ArgumentOutOfRangeException(nameof(value));
        return Math.Log10(value);
    }
}
class Program
{
    static void Main()
    {
        double val = 32.0;
        Console.WriteLine($"自然対数 ln({val}) = {LogUtils.LogNatural(val)}");
        Console.WriteLine($"底2の対数 log2({val}) = {LogUtils.Log2(val)}");
        Console.WriteLine($"底10の対数 log10({val}) = {LogUtils.Log10(val)}");
    }
}

自然対数 ln(32) = 3.4657359027997265
底2の対数 log2(32) = 5
底10の対数 log10(32) = 1.505149978319906

このようにスタティッククラスにまとめることで、対数計算に関する機能を一箇所に集約し、メンテナンス性や再利用性を高められます。

用途に応じて拡張やカスタマイズも容易です。

パフォーマンスチューニング

JIT最適化を促す書き方

JIT(Just-In-Time)コンパイラは、実行時にILコードをネイティブコードに変換し、最適化を行います。

C#でパフォーマンスを最大限に引き出すためには、JITが効果的に最適化できるコードを書くことが重要です。

対数計算などの数値処理でJIT最適化を促すポイントは以下の通りです。

ループのアンローリング(展開)

ループ内での計算を小さな単位に分割し、JITがループ展開を行いやすくします。

例えば、複数回の対数計算をまとめて処理する際に、ループの回数を減らす工夫をします。

インライン化を促す

小さなメソッドはJITがインライン化しやすいため、頻繁に呼び出す対数計算メソッドはシンプルに保つと良いです。

[MethodImpl(MethodImplOptions.AggressiveInlining)]属性を付けることでインライン化を促せます。

定数の利用

計算に使う定数はconstやreadonlyで定義し、JITが最適化しやすいようにします。

不要なボクシングの回避

ジェネリックやインターフェースを使う場合、ボクシングが発生しないように注意します。

値型のジェネリックパラメータを使うときはwhere T : struct制約を付けるなどの工夫が必要です。

以下は、JIT最適化を意識した対数計算のサンプルです。

using System;
using System.Runtime.CompilerServices;
class LogCalculator
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static double FastLog(double value)
    {
        if (value <= 0) throw new ArgumentOutOfRangeException(nameof(value));
        return Math.Log(value);
    }
}
class Program
{
    static void Main()
    {
        double[] values = { 1, 2, 3, 4, 5 };
        double sum = 0;
        for (int i = 0; i < values.Length; i++)
        {
            sum += LogCalculator.FastLog(values[i]);
        }
        Console.WriteLine($"合計: {sum}");
    }
}

合計: 4.787491742782046

このように、インライン化を促すことで関数呼び出しのオーバーヘッドを減らし、JITが効率的なコードを生成しやすくなります。

SIMD/Vector化

SIMD(Single Instruction Multiple Data)は、CPUのベクトル命令を利用して複数のデータを同時に処理する技術です。

C#ではSystem.Numerics.Vector<T>やSystem.Runtime.Intrinsics名前空間を使ってSIMDを活用できます。

対数計算は標準ライブラリのMath.Logが単一値向けのため、SIMDで直接高速化するのは難しいですが、複数の値に対して一括で対数計算を行う場合は、SIMDを使った前処理や後処理でパフォーマンス向上が期待できます。

以下は、Vector<double>を使って複数の値を一括処理する例です(対数計算は個別に呼び出していますが、SIMDでのデータロードやストアを効率化しています)。

using System;
using System.Numerics;
class Program
{
    static void Main()
    {
        double[] data = new double[Vector<double>.Count * 2];
        for (int i = 0; i < data.Length; i++)
        {
            data[i] = i + 1;
        }
        double[] results = new double[data.Length];
        for (int i = 0; i < data.Length; i += Vector<double>.Count)
        {
            var vector = new Vector<double>(data, i);
            for (int j = 0; j < Vector<double>.Count; j++)
            {
                results[i + j] = Math.Log(vector[j]);
            }
        }
        for (int i = 0; i < results.Length; i++)
        {
            Console.WriteLine($"log({data[i]}) = {results[i]:F4}");
        }
    }
}

log(1) = 0.0000
log(2) = 0.6931
log(3) = 1.0986
log(4) = 1.3863
log(5) = 1.6094
log(6) = 1.7918
log(7) = 1.9459
log(8) = 2.0794

将来的には、SIMD対応の数学ライブラリやハードウェアアクセラレーションを利用することで、対数計算のベクトル化が進む可能性があります。

Span<T>を使ったバッファ処理

Span<T>は、メモリの連続領域を安全かつ効率的に扱うための構造体で、配列やバッファの部分的な操作に適しています。

大量の対数計算を行う際に、Span<T>を使うことで不要な配列コピーを避け、メモリ効率とパフォーマンスを向上させられます。

以下は、Span<double>を使って入力データの対数を計算し、結果を同じバッファに書き込む例です。

using System;
class Program
{
    static void ComputeLogInPlace(Span<double> data)
    {
        for (int i = 0; i < data.Length; i++)
        {
            if (data[i] <= 0)
                throw new ArgumentOutOfRangeException(nameof(data), "値は正の数でなければなりません。");
            data[i] = Math.Log(data[i]);
        }
    }
    static void Main()
    {
        double[] array = { 1, 2, 3, 4, 5 };
        Span<double> span = array;
        ComputeLogInPlace(span);
        foreach (var val in array)
        {
            Console.WriteLine(val);
        }
    }
}

0
0.6931471805599453
1.0986122886681098
1.3862943611198906
1.6094379124341003

この方法は、配列のコピーを作らずに直接データを書き換えるため、メモリ使用量を抑えつつ高速に処理できます。

特に大規模データの対数変換やストリーム処理で有効です。

これらのテクニックを組み合わせることで、C#での対数計算のパフォーマンスを最大限に引き出せます。

用途や環境に応じて適切な方法を選択してください。

デバッグとテスト

高精度ライブラリでの期待値生成

対数計算のテストにおいて、正確な期待値を用意することは非常に重要です。

標準のMath.Logは高精度ですが、より高精度な計算が必要な場合や、独自実装の検証には多倍長演算ライブラリを使うと効果的です。

C#では、System.Numerics.BigIntegerは整数専用ですが、多倍長浮動小数点演算をサポートする外部ライブラリ(例：Extreme.NumericsやMPFR.NETなど)を利用することで、非常に高精度な対数計算が可能です。

以下は、外部ライブラリを使って高精度の対数値を生成し、標準実装の結果と比較するイメージ例です(実際のライブラリのAPIは異なる場合があります)。

// 仮想コード例(実際にはライブラリのAPIに合わせて実装)
using System;
using HighPrecisionMath; // 仮想の高精度ライブラリ
class Program
{
    static void Main()
    {
        double value = 10.0;
        // 高精度ライブラリで対数計算
        var highPrecValue = new HighPrecisionFloat(value);
        var highPrecLog = HighPrecisionMath.Log(highPrecValue);
        // 標準Math.Logとの比較
        double stdLog = Math.Log(value);
        Console.WriteLine($"高精度対数: {highPrecLog}");
        Console.WriteLine($"標準対数: {stdLog}");
        Console.WriteLine($"誤差: {Math.Abs((double)highPrecLog - stdLog)}");
    }
}

このように高精度の期待値を用意することで、実装の誤差やバグを検出しやすくなります。

特にエッジケースや極端な値での検証に有効です。

エッジケース網羅テスト

対数計算は入力値の範囲や特殊値によって挙動が異なるため、エッジケースを網羅的にテストすることが欠かせません。

以下のようなケースを含めると良いでしょう。

境界値
- 0に近い正の値(例：double.Epsilon、1e-308など)
- 1(対数の基準点)
- 非常に大きな値(例：double.MaxValue)
特殊値
- 0(未定義)
- 負の値(未定義)
- double.NaN
- double.PositiveInfinity
- double.NegativeInfinity
任意底の対数での特殊底
- 底が1(未定義)
- 底が0以下(未定義)

これらのケースを単体テストに組み込み、期待される例外や戻り値が返るかを検証します。

using System;
using Xunit;
public class LogTests
{
    [Theory]
    [InlineData(1.0, 0.0)]
    [InlineData(Math.E, 1.0)]
    [InlineData(double.MaxValue, double.NaN)] // 実際は計算可能だが大きな値での挙動確認
    public void TestNaturalLog(double input, double expected)
    {
        if (double.IsNaN(expected))
        {
            Assert.True(double.IsNaN(Math.Log(input)));
        }
        else
        {
            double result = Math.Log(input);
            Assert.InRange(result, expected - 1e-10, expected + 1e-10);
        }
    }
    [Fact]
    public void TestLog_NegativeInput_Throws()
    {
        Assert.True(double.IsNaN(Math.Log(-1)));
    }
    [Fact]
    public void TestLog_ZeroInput()
    {
        double result = Math.Log(0);
        Assert.Equal(double.NegativeInfinity, result);
    }
}

性能回帰テスト

パフォーマンスは継続的に監視し、回帰を防ぐことが重要です。

特に対数計算のような頻繁に呼ばれる処理では、わずかな性能低下が全体のボトルネックになる可能性があります。

性能回帰テストでは、以下のポイントを押さえます。

ベンチマークの自動化

BenchmarkDotNetなどのフレームワークを使い、定期的にベンチマークを実行して結果を記録します。

基準値との比較

過去のベンチマーク結果と比較し、性能が低下していないかをチェックします。

CI/CDパイプラインへの組み込み

継続的インテグレーション環境で性能テストを実行し、問題があればアラートを出す仕組みを作ります。

以下はBenchmarkDotNetを使った簡単な性能テスト例です。

using System;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
public class LogBenchmark
{
    private double[] values;
    [GlobalSetup]
    public void Setup()
    {
        values = new double[1000];
        var rand = new Random();
        for (int i = 0; i < values.Length; i++)
        {
            values[i] = rand.NextDouble() * 100 + 1; // 1以上の値
        }
    }
    [Benchmark]
    public double MathLog()
    {
        double sum = 0;
        foreach (var v in values)
        {
            sum += Math.Log(v);
        }
        return sum;
    }
}
class Program
{
    static void Main()
    {
        var summary = BenchmarkRunner.Run<LogBenchmark>();
    }
}