高精度.NET数值计算库Sdcb.Arithmetic全平台发布

Stopwatch sw = Stopwatch.StartNew();
int count = 10;

BigInteger b = new BigInteger();
for (int c = 0; c < count; ++c)
{
 b = 1;
 for (int i = 1; i <= 65536; ++i)
 {
  b *= 2;
 }
}
Console.WriteLine($"耗时：{sw.Elapsed.TotalMilliseconds / count:F2}ms");
Console.WriteLine($"2^65536最后20位数字：{b.ToString()[^20..]}");

耗时：94.00ms
2^65536最后20位数字：45587895905719156736

Stopwatch sw = Stopwatch.StartNew();
int count = 10;

GmpInteger b = new GmpInteger();
for (int c = 0; c < count; ++c)
{
 b = 1;
for (int i = 1; i <= 65536; ++i)
 {
  b *= 2;
 }
}

Console.WriteLine($"耗时：{sw.Elapsed.TotalMilliseconds / count:F2}ms");
Console.WriteLine($"2^65536最后20位数字：{b.ToString()[^20..]}");

耗时：89.52ms
2^65536最后20位数字：45587895905719156736

// 安装NuGet包：Sdcb.Arithmetic.Gmp
// 安装NuGet包：Sdcb.Arithmetic.Gmp.runtime.win64 （或其它对应环境包）
// 函数需要标注unsafe
// 项目需要启用unsafe编译选项
Stopwatch sw = Stopwatch.StartNew();
int count = 10;
Mpz_t mpz;
GmpLib.__gmpz_init((IntPtr)(&mpz));

for (int c = 0; c < count; ++c)
{ 
 GmpLib.__gmpz_set_si((IntPtr)(&mpz), 1);
for (int i = 1; i <= 65536; ++i)
 {
  GmpLib.__gmpz_mul_si((IntPtr)(&mpz), (IntPtr)(&mpz), 2);
 }
}
sw.Stop();

IntPtr ret = GmpLib.__gmpz_get_str(IntPtr.Zero, 10, (IntPtr)(&mpz));
string wholeStr = Marshal.PtrToStringUTF8(ret)!;
GmpMemory.Free(ret);

Console.WriteLine($"耗时：{sw.Elapsed.TotalMilliseconds / count:F2}ms");
Console.WriteLine($"2^65536最后20位数字：{wholeStr[^20..]}");

GmpLib.__gmpz_clear((IntPtr)(&mpz));

耗时：20.87ms
2^65536最后20位数字：45587895905719156736

// 安装NuGet包：Sdcb.Arithmetic.Gmp
// 安装NuGet包：Sdcb.Arithmetic.Gmp.runtime.win64 （或其它对应环境包）
Stopwatch sw = Stopwatch.StartNew();
int count = 10;

using GmpInteger b = new GmpInteger();
for (int c = 0; c < count; ++c)
{
 b.Assign(1);
for (int i = 1; i <= 65536; ++i)
 {
  GmpInteger.MultiplyInplace(b, b, 2);
 }
}

Console.WriteLine($"耗时：{sw.Elapsed.TotalMilliseconds / count:F2}ms");
Console.WriteLine($"2^65536最后20位数字：{b.ToString()[^20..]}");

import java.math.BigInteger;
import java.time.Duration;
import java.time.Instant;

publicclass Main {
    public static void main(String[] args) {
        Instant start = Instant.now();

        int count = 10;
        BigInteger b = BigInteger.ONE;

        for (int c = 0; c < count; ++c) {
            b = BigInteger.ONE;
            for (int i = 1; i <= 65536; ++i) {
                b = b.multiply(BigInteger.valueOf(2));
            }
        }

        Instant finish = Instant.now();
        long timeElapsed = Duration.between(start, finish).toMillis();

        String str = b.toString();
        String last20Digits = str.substring(str.length() - 20);

        System.out.printf("耗时：%f ms\n", (double) timeElapsed / count);
        System.out.println("2^65536最后20位数字：" + last20Digits);
    }
}

耗时：103.100000 ms
2^65536最后20位数字：45587895905719156736

// Install NuGet package: Sdcb.Arithmetic.Gmp
// Install NuGet package: Sdcb.Arithmetic.Gmp.runtime.win-x64(for windows)
using Sdcb.Arithmetic.Gmp;

Stopwatch sw = Stopwatch.StartNew();
using GmpFloat pi = CalcPI();

double elapsed = sw.Elapsed.TotalMilliseconds;
Console.WriteLine($"耗时：{elapsed:F2}ms");
Console.WriteLine($"结果：{pi:N1000000}");

GmpFloat CalcPI(int inputDigits = 1_000_000)
{
    constdouble DIGITS_PER_TERM = 14.1816474627254776555; // = log(53360^3) / log(10)
    int DIGITS = (int)Math.Max(inputDigits, Math.Ceiling(DIGITS_PER_TERM));
    uint PREC = (uint)(DIGITS * Math.Log2(10));
    int N = (int)(DIGITS / DIGITS_PER_TERM);
    constint A = 13591409;
    constint B = 545140134;
    constint C = 640320;
    constint D = 426880;
    constint E = 10005;
    constdouble E3_24 = (double)C * C * C / 24;

    using PQT pqt = ComputePQT(0, N);

    GmpFloat pi = new(precision: PREC);
    // pi = D * sqrt((mpf_class)E) * PQT.Q;
    pi.Assign(GmpFloat.From(D, PREC) * GmpFloat.Sqrt((GmpFloat)E, PREC) * (GmpFloat)pqt.Q);
    // pi /= (A * PQT.Q + PQT.T);
    GmpFloat.DivideInplace(pi, pi, GmpFloat.From(A * pqt.Q + pqt.T, PREC));
    return pi;

    PQT ComputePQT(int n1, int n2)
    {
        int m;

        if (n1 + 1 == n2)
        {
            PQT res = new()
   
            {
                P = GmpInteger.From(2 * n2 - 1)
            };
            GmpInteger.MultiplyInplace(res.P, res.P, 6 * n2 - 1);
            GmpInteger.MultiplyInplace(res.P, res.P, 6 * n2 - 5);

            GmpInteger q = GmpInteger.From(E3_24);
            GmpInteger.MultiplyInplace(q, q, n2);
            GmpInteger.MultiplyInplace(q, q, n2);
            GmpInteger.MultiplyInplace(q, q, n2);
            res.Q = q;

            GmpInteger t = GmpInteger.From(B);
            GmpInteger.MultiplyInplace(t, t, n2);
            GmpInteger.AddInplace(t, t, A);
            GmpInteger.MultiplyInplace(t, t, res.P);
            // res.T = (A + B * n2) * res.P;            
            if ((n2 & 1) == 1) GmpInteger.NegateInplace(t, t);
            res.T = t;

            return res;
        }
        else
        {
            m = (n1 + n2) / 2;
            PQT res1 = ComputePQT(n1, m);
            using PQT res2 = ComputePQT(m, n2);
            GmpInteger p = res1.P * res2.P;
            GmpInteger q = res1.Q * res2.Q;

            // t = res1.T * res2.Q + res1.P * res2.T
            GmpInteger.MultiplyInplace(res1.T, res1.T, res2.Q);
            GmpInteger.MultiplyInplace(res1.P, res1.P, res2.T);
            GmpInteger.AddInplace(res1.T, res1.T, res1.P);
            res1.P.Dispose();
            res1.Q.Dispose();
            returnnew PQT
            {
                P = p,
                Q = q,
                T = res1.T,
            };
        }
    }
}

publicrefstruct PQT
{
    public GmpInteger P;
    public GmpInteger Q;
    public GmpInteger T;

    public readonly void Dispose()
    {
        P?.Dispose();
        Q?.Dispose();
        T?.Dispose();
    }
}

耗时：435.35ms
结果：3.141592653589793238462643383...83996346460422090106105779458151