【C#】Math.Sqrtで簡単・高速に平方根を求める実践テクニック

using System;
class Program
{
    static void Main()
    {
        double number = 16.0;
        double result = Math.Sqrt(number);
        Console.WriteLine($"16の平方根は: {result}");
    }
}

16の平方根は: 4

float floatNumber = 9.0f;
double result = Math.Sqrt(floatNumber); // floatはdoubleに暗黙変換されるため問題なし

decimal decimalNumber = 25.0m;
double result = Math.Sqrt((double)decimalNumber);

using System;
class Program
{
    static void Main()
    {
        double positive = 25.0;
        double zero = 0.0;
        double negative = -9.0;
        Console.WriteLine($"25の平方根: {Math.Sqrt(positive)}");
        Console.WriteLine($"0の平方根: {Math.Sqrt(zero)}");
        Console.WriteLine($"-9の平方根: {Math.Sqrt(negative)}");
    }
}

25の平方根: 5
0の平方根: 0
-9の平方根: NaN

using System;
class Program
{
    static void Main()
    {
        double nanResult = Math.Sqrt(-1.0);
        double posInfResult = Math.Sqrt(double.PositiveInfinity);
        double negInfResult = Math.Sqrt(double.NegativeInfinity);
        Console.WriteLine($"-1の平方根: {nanResult} (IsNaN: {double.IsNaN(nanResult)})");
        Console.WriteLine($"+∞の平方根: {posInfResult}");
        Console.WriteLine($"-∞の平方根: {negInfResult} (IsNaN: {double.IsNaN(negInfResult)})");
    }
}

-1の平方根: NaN (IsNaN: True)
+∞の平方根: ∞
-∞の平方根: NaN (IsNaN: True)

using System;
class Program
{
    static void Main()
    {
        float floatValue = 2.0f;
        double doubleValue = 2.0;
        double sqrtFloat = Math.Sqrt(floatValue); // floatはdoubleに暗黙変換される
        double sqrtDouble = Math.Sqrt(doubleValue);
        Console.WriteLine($"float値の平方根: {sqrtFloat}");
        Console.WriteLine($"double値の平方根: {sqrtDouble}");
    }
}

float値の平方根: 1.4142135623731
double値の平方根: 1.4142135623731

decimal decimalValue = 2.25m;
double sqrtDecimal = Math.Sqrt((double)decimalValue);
Console.WriteLine($"decimal値の平方根: {sqrtDecimal}");

using System;
class Program
{
    static void Main()
    {
        double[] testValues = { 2.0, 2.25, 10.0, 123456.789 };
        foreach (var val in testValues)
        {
            double sqrtVal = Math.Sqrt(val);
            double squared = sqrtVal * sqrtVal;
            double error = squared - val;
            Console.WriteLine($"元の値: {val}");
            Console.WriteLine($"平方根: {sqrtVal}");
            Console.WriteLine($"平方根の二乗: {squared}");
            Console.WriteLine($"誤差: {error}");
            Console.WriteLine();
        }
    }
}

元の値: 2
平方根: 1.4142135623730951
平方根の二乗: 2.0000000000000004
誤差: 4.440892098500626E-16

元の値: 2.25
平方根: 1.5
平方根の二乗: 2.25
誤差: 0

元の値: 10
平方根: 3.1622776601683795
平方根の二乗: 10.000000000000002
誤差: 1.7763568394002505E-15

元の値: 123456.789
平方根: 351.3641828644462
平方根の二乗: 123456.78899999999
誤差: -1.4551915228366852E-11

using System;
using System.Threading.Tasks;
class Program
{
    static void Main()
    {
        double[] values = { 4.0, 9.0, 16.0, 25.0, 36.0 };
        Parallel.ForEach(values, val =>
        {
            double result = Math.Sqrt(val);
            Console.WriteLine($"値: {val}, 平方根: {result}");
        });
    }
}

値: 4, 平方根: 2
値: 9, 平方根: 3
値: 16, 平方根: 4
値: 25, 平方根: 5
値: 36, 平方根: 6

using System;
class Program
{
    static void Main()
    {
        double input = -16.0;
        double result = Math.Sqrt(input);
        if (double.IsNaN(result))
        {
            Console.WriteLine("エラー: 負の数の平方根は計算できません。");
        }
        else
        {
            Console.WriteLine($"{input}の平方根は: {result}");
        }
    }
}

エラー: 負の数の平方根は計算できません。

using System;
class MathHelper
{
    public static double SafeSqrt(double value)
    {
        double result = Math.Sqrt(value);
        if (double.IsNaN(result))
        {
            throw new ArgumentOutOfRangeException(nameof(value), "負の数の平方根は計算できません。");
        }
        return result;
    }
}
class Program
{
    static void Main()
    {
        try
        {
            double input = -9.0;
            double sqrt = MathHelper.SafeSqrt(input);
            Console.WriteLine($"{input}の平方根は: {sqrt}");
        }
        catch (ArgumentOutOfRangeException ex)
        {
            Console.WriteLine($"例外発生: {ex.Message}");
        }
    }
}

例外発生: 負の数の平方根は計算できません。

using System;
class MathHelper
{
    public static bool TrySqrt(double value, out double result)
    {
        result = Math.Sqrt(value);
        if (double.IsNaN(result))
        {
            result = 0;
            return false;
        }
        return true;
    }
}
class Program
{
    static void Main()
    {
        double input = -4.0;
        if (MathHelper.TrySqrt(input, out double sqrt))
        {
            Console.WriteLine($"{input}の平方根は: {sqrt}");
        }
        else
        {
            Console.WriteLine("エラー: 負の数の平方根は計算できません。");
        }
    }
}

エラー: 負の数の平方根は計算できません。

using System;
using System.Collections.Generic;
class SqrtCache
{
    private Dictionary<double, double> cache = new Dictionary<double, double>();
    public double GetSqrt(double value)
    {
        if (cache.TryGetValue(value, out double cachedResult))
        {
            return cachedResult;
        }
        double result = Math.Sqrt(value);
        cache[value] = result;
        return result;
    }
}
class Program
{
    static void Main()
    {
        var sqrtCache = new SqrtCache();
        double[] values = { 16.0, 25.0, 16.0, 25.0, 36.0 };
        foreach (var val in values)
        {
            double sqrt = sqrtCache.GetSqrt(val);
            Console.WriteLine($"{val}の平方根: {sqrt}");
        }
    }
}

16の平方根: 4
25の平方根: 5
16の平方根: 4
25の平方根: 5
36の平方根: 6

using System;
using System.Numerics;
class Program
{
    static void Main()
    {
        double[] values = { 4.0, 9.0, 16.0, 25.0 };
        int vectorSize = Vector<double>.Count; // SIMD幅(環境依存)
        var vector = new Vector<double>(values);
        var sqrtVector = Vector.SquareRoot(vector);
        for (int i = 0; i < vectorSize; i++)
        {
            Console.WriteLine($"{values[i]}の平方根: {sqrtVector[i]}");
        }
    }
}

4の平方根: 2
9の平方根: 3
16の平方根: 4
25の平方根: 5

using System;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;
class Program
{
    static void Main()
    {
        if (!Avx.IsSupported)
        {
            Console.WriteLine("AVXがサポートされていません。");
            return;
        }
        float[] values = { 1f, 4f, 9f, 16f, 25f, 36f, 49f, 64f };
        var vector = Vector256.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
        var sqrtVector = Avx.Sqrt(vector);
        for (int i = 0; i < 8; i++)
        {
            Console.WriteLine($"{values[i]}の平方根: {sqrtVector.GetElement(i)}");
        }
    }
}

1の平方根: 1
4の平方根: 2
9の平方根: 3
16の平方根: 4
25の平方根: 5
36の平方根: 6
49の平方根: 7
64の平方根: 8

using System;
using System.Threading.Tasks;
class Program
{
    static void Main()
    {
        double[] values = new double[1000000];
        for (int i = 0; i < values.Length; i++)
        {
            values[i] = i + 1;
        }
        double[] results = new double[values.Length];
        Parallel.For(0, values.Length, i =>
        {
            results[i] = Math.Sqrt(values[i]);
        });
        Console.WriteLine($"最初の5つの平方根: {string.Join(", ", results[..5])}");
    }
}

最初の5つの平方根: 1, 1.4142135623730951, 1.7320508075688772, 2, 2.23606797749979

using System;
using System.Diagnostics;
using System.Numerics;
using System.Threading.Tasks;
class Program
{
    static void Main()
    {
        const int count = 10_000_000;
        double[] values = new double[count];
        for (int i = 0; i < count; i++)
        {
            values[i] = i + 1;
        }
        double[] results = new double[count];
        // 単純ループ
        var sw = Stopwatch.StartNew();
        for (int i = 0; i < count; i++)
        {
            results[i] = Math.Sqrt(values[i]);
        }
        sw.Stop();
        Console.WriteLine($"単純ループ: {sw.ElapsedMilliseconds} ms");
        // SIMD (Vector<double>)
        sw.Restart();
        int vectorSize = Vector<double>.Count;
        int iSimd;
        for (iSimd = 0; iSimd <= count - vectorSize; iSimd += vectorSize)
        {
            var v = new Vector<double>(values, iSimd);
            var sqrtV = Vector.SquareRoot(v);
            sqrtV.CopyTo(results, iSimd);
        }
        // 残りの要素を処理
        for (; iSimd < count; iSimd++)
        {
            results[iSimd] = Math.Sqrt(values[iSimd]);
        }
        sw.Stop();
        Console.WriteLine($"SIMD: {sw.ElapsedMilliseconds} ms");
        // 並列処理
        sw.Restart();
        Parallel.For(0, count, i =>
        {
            results[i] = Math.Sqrt(values[i]);
        });
        sw.Stop();
        Console.WriteLine($"並列処理: {sw.ElapsedMilliseconds} ms");
    }
}

単純ループ: 143 ms
SIMD: 11 ms
並列処理: 26 ms

x_{n+1} = 0.5 * (x_n + S / x_n)

using System;
class Program
{
    static double NewtonSqrt(double S, double tolerance = 1e-10, int maxIterations = 20)
    {
        if (S < 0) throw new ArgumentOutOfRangeException(nameof(S), "負の数の平方根は計算できません。");
        if (S == 0) return 0;
        double x = S; // 初期値
        for (int i = 0; i < maxIterations; i++)
        {
            double xNext = 0.5 * (x + S / x);
            if (Math.Abs(x - xNext) < tolerance)
                return xNext;
            x = xNext;
        }
        return x;
    }
    static void Main()
    {
        double value = 25.0;
        double sqrtApprox = NewtonSqrt(value);
        Console.WriteLine($"{value}の平方根(Newton  -Raphson法): {sqrtApprox}");
    }
}

25の平方根(Newton  -Raphson法): 5

double initialGuess = S > 1 ? S / 2 : 1;

using System;
using System.Runtime.InteropServices;
class Program
{
    static float FastInverseSqrt(float number)
    {
        unsafe
        {
            float x2 = number * 0.5f;
            float y = number;
            int i;
            // 浮動小数点数のビットを整数として読み取る
            i = *(int*)&y;
            // 魔法の定数で補正
            i = 0x5f3759df - (i >> 1);
            y = *(float*)&i;
            // 1回のニュートン法反復で精度向上
            y = y * (1.5f - (x2 * y * y));
            return y;
        }
    }
    static void Main()
    {
        float value = 25.0f;
        float invSqrt = FastInverseSqrt(value);
        float sqrtApprox = 1.0f / invSqrt;
        Console.WriteLine($"{value}の平方根(高速逆平方根法): {sqrtApprox}");
    }
}

25の平方根(高速逆平方根法): 5.007768

using System;
class Physics
{
    public static double CalculateDistance(double x1, double y1, double x2, double y2)
    {
        double dx = x2 - x1;
        double dy = y2 - y1;
        return Math.Sqrt(dx * dx + dy * dy);
    }
}
class Program
{
    static void Main()
    {
        double x1 = 1.0, y1 = 2.0;
        double x2 = 4.0, y2 = 6.0;
        double distance = Physics.CalculateDistance(x1, y1, x2, y2);
        Console.WriteLine($"2点間の距離: {distance}");
    }
}

2点間の距離: 5

using System;
class ImageProcessing
{
    public static double CalculateGradientMagnitude(int gx, int gy)
    {
        return Math.Sqrt(gx * gx + gy * gy);
    }
}
class Program
{
    static void Main()
    {
        int gx = 3; // 水平方向の勾配
        int gy = 4; // 垂直方向の勾配
        double magnitude = ImageProcessing.CalculateGradientMagnitude(gx, gy);
        Console.WriteLine($"勾配強度: {magnitude}");
    }
}

勾配強度: 5

using System;
class Finance
{
    public static double CalculateVolatility(double variance)
    {
        return Math.Sqrt(variance);
    }
}
class Program
{
    static void Main()
    {
        double variance = 0.0025; // 分散の例
        double volatility = Finance.CalculateVolatility(variance);
        Console.WriteLine($"ボラティリティ(標準偏差): {volatility}");
    }
}

ボラティリティ(標準偏差): 0.05

using System;
class MachineLearning
{
    public static double CalculateL2Norm(double[] vector)
    {
        double sumSquares = 0;
        foreach (var v in vector)
        {
            sumSquares += v * v;
        }
        return Math.Sqrt(sumSquares);
    }
}
class Program
{
    static void Main()
    {
        double[] features = { 3.0, 4.0 };
        double l2Norm = MachineLearning.CalculateL2Norm(features);
        Console.WriteLine($"L2ノルム: {l2Norm}");
    }
}

L2ノルム: 5

using System;
static class MathExtensions
{
    public static double SafeSqrt(this double value)
    {
        if (value < 0)
            throw new ArgumentOutOfRangeException(nameof(value), "負の数の平方根は計算できません。");
        return Math.Sqrt(value);
    }
}
class Program
{
    static void Main()
    {
        double number = 16.0;
        double result = number.SafeSqrt();
        Console.WriteLine($"{number}の平方根: {result}");
    }
}

16の平方根: 4

public static class MathUtility
{
    public static bool TrySqrt(double value, out double result)
    {
        if (value < 0)
        {
            result = 0;
            return false;
        }
        result = Math.Sqrt(value);
        return true;
    }
    public static double NewtonSqrt(double value, double tolerance = 1e-10, int maxIterations = 20)
    {
        if (value < 0) throw new ArgumentOutOfRangeException(nameof(value));
        if (value == 0) return 0;
        double x = value;
        for (int i = 0; i < maxIterations; i++)
        {
            double xNext = 0.5 * (x + value / x);
            if (Math.Abs(x - xNext) < tolerance)
                return xNext;
            x = xNext;
        }
        return x;
    }
}

using NUnit.Framework;
[TestFixture]
public class MathUtilityTests
{
    [Test]
    public void TrySqrt_ValidInput_ReturnsTrue()
    {
        bool success = MathUtility.TrySqrt(9, out double result);
        Assert.IsTrue(success);
        Assert.AreEqual(3, result, 1e-10);
    }
    [Test]
    public void TrySqrt_NegativeInput_ReturnsFalse()
    {
        bool success = MathUtility.TrySqrt(-1, out double result);
        Assert.IsFalse(success);
        Assert.AreEqual(0, result);
    }
    [Test]
    public void NewtonSqrt_AccuracyTest()
    {
        double expected = Math.Sqrt(2);
        double actual = MathUtility.NewtonSqrt(2);
        Assert.AreEqual(expected, actual, 1e-9);
    }
    [Test]
    public void NewtonSqrt_NegativeInput_Throws()
    {
        Assert.Throws<ArgumentOutOfRangeException>(() => MathUtility.NewtonSqrt(-1));
    }
}

using System;
class Program
{
    static void Main()
    {
        double largeValue = double.MaxValue;
        double sqrtLarge = Math.Sqrt(largeValue);
        Console.WriteLine($"MaxValueの平方根: {sqrtLarge}");
        double smallValue = double.Epsilon;
        double sqrtSmall = Math.Sqrt(smallValue);
        Console.WriteLine($"Epsilonの平方根: {sqrtSmall}");
    }
}

MaxValueの平方根: 1.3407807929942596E+154
Epsilonの平方根: 1.4916681462400413E-08

using System;
class Program
{
    static void Main()
    {
        double value = 1e-10;
        double sqrtVal = Math.Sqrt(value);
        double squared = sqrtVal * sqrtVal;
        double error = squared - value;
        Console.WriteLine($"元の値: {value}");
        Console.WriteLine($"平方根: {sqrtVal}");
        Console.WriteLine($"平方根の二乗: {squared}");
        Console.WriteLine($"誤差: {error}");
    }
}

元の値: 1E-10
平方根: 1E-05
平方根の二乗: 1E-10
誤差: 0