public void Atan2UnnormalValueTest()
{
MultiPrecision <Pow2.N8>[] vs = new MultiPrecision <Pow2.N8>[] {
MultiPrecision <Pow2.N8> .NaN,
MultiPrecision <Pow2.N8> .PositiveInfinity,
MultiPrecision <Pow2.N8> .NegativeInfinity,
};
foreach (MultiPrecision <Pow2.N8> v in vs)
{
MultiPrecision <Pow2.N8> y = MultiPrecision <Pow2.N8> .Atan2(0, v);
Assert.IsTrue(y.IsNaN);
}
foreach (MultiPrecision <Pow2.N8> v in vs)
{
MultiPrecision <Pow2.N8> y = MultiPrecision <Pow2.N8> .Atan2(v, 0);
Assert.IsTrue(y.IsNaN);
}
foreach (MultiPrecision <Pow2.N8> v in vs)
{
MultiPrecision <Pow2.N8> y = MultiPrecision <Pow2.N8> .Atan2(v, v);
Assert.IsTrue(y.IsNaN);
}
}
public void GammaBorderTest()
{
MultiPrecision <Pow2.N8>[] borders = new MultiPrecision <Pow2.N8>[] { 0.5, 1 };
foreach (MultiPrecision <Pow2.N8> b in borders)
{
List <MultiPrecision <Pow2.N8> > ys = new();
foreach (MultiPrecision <Pow2.N8> x in TestTool.EnumerateNeighbor(b))
{
MultiPrecision <Pow2.N8> y = MultiPrecision <Pow2.N8> .Gamma(x);
Console.WriteLine(x);
Console.WriteLine(x.ToHexcode());
Console.WriteLine(y);
Console.WriteLine(y.ToHexcode());
Console.Write("\n");
TestTool.Tolerance(Approx.Gamma((double)x), y, ignore_sign: true);
ys.Add(y);
}
TestTool.NearlyNeighbors(ys, 2);
TestTool.SmoothnessSatisfied(ys, 1);
TestTool.MonotonicitySatisfied(ys);
Console.Write("\n");
}
}
private static MultiPrecision <SterlingExpand <N> > DiffLogSterlingTerm(MultiPrecision <SterlingExpand <N> > z)
{
MultiPrecision <SterlingExpand <N> > v = 1 / z;
MultiPrecision <SterlingExpand <N> > w = v * v;
MultiPrecision <SterlingExpand <N> > x = 0, u = w;
long k = 1;
foreach (MultiPrecision <SterlingExpand <N> > s in Consts.Gamma.Sterling.Coef)
{
MultiPrecision <SterlingExpand <N> > c = k * (u * s);
x += c;
if (c.IsZero || x.Exponent - c.Exponent > MultiPrecision <SterlingExpand <N> > .Bits)
{
break;
}
k += 2;
u *= w;
}
return(x);
}
public void Atan2BorderTest()
{
foreach (MultiPrecision <Pow2.N8> x in TestTool.EnumerateNeighbor <Pow2.N8>(0))
{
MultiPrecision <Pow2.N8> y = MultiPrecision <Pow2.N8> .Atan2(x, 1);
Console.WriteLine(x);
Console.WriteLine(x.ToHexcode());
Console.WriteLine(y);
Console.WriteLine(y.ToHexcode());
Console.Write("\n");
TestTool.Tolerance(Math.Atan2((double)x, 1), y);
}
Console.Write("\n");
foreach (MultiPrecision <Pow2.N8> x in TestTool.EnumerateNeighbor <Pow2.N8>(0))
{
MultiPrecision <Pow2.N8> y = MultiPrecision <Pow2.N8> .Atan2(x, -1);
Console.WriteLine(x);
Console.WriteLine(x.ToHexcode());
Console.WriteLine(y);
Console.WriteLine(y.ToHexcode());
Console.Write("\n");
TestTool.Tolerance(Math.Atan2((double)x, -1), y);
}
Console.Write("\n");
foreach (MultiPrecision <Pow2.N8> x in TestTool.EnumerateNeighbor <Pow2.N8>(0))
{
MultiPrecision <Pow2.N8> y = MultiPrecision <Pow2.N8> .Atan2(1, x);
Console.WriteLine(x);
Console.WriteLine(x.ToHexcode());
Console.WriteLine(y);
Console.WriteLine(y.ToHexcode());
Console.Write("\n");
TestTool.Tolerance(Math.Atan2(1, (double)x), y);
}
Console.Write("\n");
foreach (MultiPrecision <Pow2.N8> x in TestTool.EnumerateNeighbor <Pow2.N8>(0))
{
MultiPrecision <Pow2.N8> y = MultiPrecision <Pow2.N8> .Atan2(-1, x);
Console.WriteLine(x);
Console.WriteLine(x.ToHexcode());
Console.WriteLine(y);
Console.WriteLine(y.ToHexcode());
Console.Write("\n");
TestTool.Tolerance(Math.Atan2(-1, (double)x), y);
}
}
public void MaxSearchTest()
{
MultiPrecision <Pow2.N4> curve(long x, long a) => - (x - a) * (x - a);
for (long a = -50; a <= 450; a++)
{
Console.WriteLine($"a = {a}");
MaxSearch <Pow2.N4> search = new MaxSearch <Pow2.N4>((100, 200), (0, 400));
while (!search.IsSearched)
{
foreach (long sample_point in search.SampleRequests)
{
MultiPrecision <Pow2.N4> sample = curve(sample_point, a);
search.PushSampleResult(sample_point, sample);
Console.WriteLine($"sample {sample_point}, {sample}");
}
Console.WriteLine($"step {search.Step}, maxpoint {search.MaxPoint}\n");
search.ReflashSampleRequests();
}
Assert.AreEqual(1, search.Step);
Assert.AreEqual(Math.Min(400, Math.Max(0, a)), search.MaxPoint);
Assert.AreEqual(a > 0 && a < 400, search.IsConvergenced);
}
}
public void NullCmpTest()
{
MultiPrecision <Pow2.N8> x = 1;
MultiPrecision <Pow2.N8> n = null;
Assert.IsTrue(x != null);
Assert.IsTrue(x != n);
Assert.IsTrue(null != x);
Assert.IsTrue(n != x);
Assert.IsFalse(x == null);
Assert.IsFalse(x == n);
Assert.IsFalse(null == x);
Assert.IsFalse(n == x);
Assert.IsFalse(n != null);
Assert.IsFalse(null != n);
Assert.IsTrue(n == null);
Assert.IsTrue(null == n);
#pragma warning disable CS1718
Assert.IsTrue(n == n);
Assert.IsFalse(n != n);
#pragma warning restore CS1718
}
public static MultiPrecision <N> Pow(MultiPrecision <N> x, long n)
{
if (x.IsNaN)
{
return(NaN);
}
if (n == 0)
{
return(One);
}
ulong n_abs = UIntUtil.Abs(n);
MultiPrecision <Plus1 <N> > y = 1, z = x.Convert <Plus1 <N> >();
while (n_abs > 0)
{
if ((n_abs & 1) == 1)
{
y *= z;
}
z *= z;
n_abs >>= 1;
}
return(((n > 0) ? y : (1 / y)).Convert <N>());
}
private static MultiPrecision <Plus1 <N> > BesselKLimit(MultiPrecision <N> nu, MultiPrecision <N> z)
{
Consts.BesselLimitCoef table = Consts.Bessel.LimitCoef(nu);
MultiPrecision <Plus4 <N> > z_ex = z.Convert <Plus4 <N> >();
MultiPrecision <Plus4 <N> > v = 1 / z_ex;
MultiPrecision <Plus4 <N> > x = 0, p = 1;
for (int k = 0; k <= Consts.BesselIK.LimitApproxTerms; k++, p *= v)
{
MultiPrecision <Plus4 <N> > c = p * table.Value(k);
x += c;
if (c.IsZero || x.Exponent - c.Exponent > MultiPrecision <Plus1 <N> > .Bits)
{
break;
}
}
MultiPrecision <Plus4 <N> > r =
MultiPrecision <Plus4 <N> > .Exp(-z_ex) * MultiPrecision <Plus4 <N> > .Sqrt(MultiPrecision <Plus4 <N> > .PI / (2 * z_ex));
MultiPrecision <Plus4 <N> > y = r * x;
return(y.Convert <Plus1 <N> >());
}
public static MultiPrecision <N> BesselI(MultiPrecision <N> nu, MultiPrecision <N> x)
{
if (MultiPrecision <N> .Abs(nu) > 64)
{
throw new ArgumentOutOfRangeException(
nameof(nu),
"In the calculation of the Bessel function, nu with an absolute value greater than 64 is not supported."
);
}
if (nu.IsNaN || x.IsNaN || x.Sign == Sign.Minus)
{
return(MultiPrecision <N> .NaN);
}
if (nu.Sign == Sign.Minus && nu == MultiPrecision <N> .Truncate(nu))
{
return(BesselI(MultiPrecision <N> .Abs(nu), x));
}
if (nu - MultiPrecision <N> .Point5 == MultiPrecision <N> .Floor(nu))
{
long n = (long)MultiPrecision <N> .Floor(nu);
if (n >= -2 && n < 2)
{
MultiPrecision <Plus1 <N> > x_ex = x.Convert <Plus1 <N> >();
MultiPrecision <Plus1 <N> > r = MultiPrecision <Plus1 <N> > .Sqrt2 / MultiPrecision <Plus1 <N> > .Sqrt(MultiPrecision <Plus1 <N> > .PI *x_ex);
if (n == -2)
{
return(-(r * (MultiPrecision <Plus1 <N> > .Cosh(x_ex) / x_ex - MultiPrecision <Plus1 <N> > .Sinh(x_ex))).Convert <N>());
}
if (n == -1)
{
return((r * MultiPrecision <Plus1 <N> > .Cosh(x_ex)).Convert <N>());
}
if (n == 0)
{
MultiPrecision <N> y = (r * MultiPrecision <Plus1 <N> > .Sinh(x_ex)).Convert <N>();
return(y.IsNormal ? y : 0);
}
if (n == 1)
{
MultiPrecision <N> y = -(r * (MultiPrecision <Plus1 <N> > .Sinh(x_ex) / x_ex - MultiPrecision <Plus1 <N> > .Cosh(x_ex))).Convert <N>();
return(y.IsNormal ? y : 0);
}
}
}
if (x < Consts.BesselIK.ApproxThreshold)
{
return(BesselINearZero(nu, x).Convert <N>());
}
else
{
return(BesselILimit(nu, x).Convert <N>());
}
}
public void IOTest()
{
const string filename_bin = "mp_iotest.bin";
MultiPrecision <Pow2.N8>[] vs =
{
MultiPrecision <Pow2.N8> .Zero,
MultiPrecision <Pow2.N8> .MinusZero,
1, 2, 3, 4, 5, 7, 10, 11, 13, 100, 1000,
-1, -2, -3, -4, -5, -7, -10, -11, -13, -100, -1000,
MultiPrecision <Pow2.N8> .One / 2,
MultiPrecision <Pow2.N8> .One / 3,
MultiPrecision <Pow2.N8> .One / 4,
MultiPrecision <Pow2.N8> .One / 5,
MultiPrecision <Pow2.N8> .One / 7,
MultiPrecision <Pow2.N8> .One / 10,
MultiPrecision <Pow2.N8> .One / 11,
MultiPrecision <Pow2.N8> .One / 13,
MultiPrecision <Pow2.N8> .One / 100,
MultiPrecision <Pow2.N8> .One / 1000,
MultiPrecision <Pow2.N8> .MinusOne / 2,
MultiPrecision <Pow2.N8> .MinusOne / 3,
MultiPrecision <Pow2.N8> .MinusOne / 4,
MultiPrecision <Pow2.N8> .MinusOne / 5,
MultiPrecision <Pow2.N8> .MinusOne / 7,
MultiPrecision <Pow2.N8> .MinusOne / 10,
MultiPrecision <Pow2.N8> .MinusOne / 11,
MultiPrecision <Pow2.N8> .MinusOne / 13,
MultiPrecision <Pow2.N8> .MinusOne / 100,
MultiPrecision <Pow2.N8> .MinusOne / 1000,
MultiPrecision <Pow2.N8> .PositiveInfinity,
MultiPrecision <Pow2.N8> .NegativeInfinity,
MultiPrecision <Pow2.N8> .NaN,
};
List <MultiPrecision <Pow2.N8> > us = new List <MultiPrecision <Pow2.N8> >();
using (BinaryWriter stream = new BinaryWriter(File.OpenWrite(filename_bin))) {
foreach (MultiPrecision <Pow2.N8> v in vs)
{
stream.Write(v);
}
}
using (BinaryReader stream = new BinaryReader(File.OpenRead(filename_bin))) {
for (int i = 0; i < vs.Length; i++)
{
MultiPrecision <Pow2.N8> u = stream.ReadMultiPrecision <Pow2.N8>();
us.Add(u);
}
}
for (int i = 0; i < vs.Length; i++)
{
Assert.AreEqual(vs[i], us[i]);
}
File.Delete(filename_bin);
}
public static MultiPrecision <N> InverseErf(MultiPrecision <N> x)
{
if (x.IsNaN || x < MinusOne || x > One)
{
return(NaN);
}
if (x == MinusOne)
{
return(NegativeInfinity);
}
if (x == One)
{
return(PositiveInfinity);
}
if (x.Sign == Sign.Minus)
{
return(-InverseErf(Abs(x)));
}
if (x.Exponent <= -Bits / 4)
{
MultiPrecision <N> w = PI * x * x;
MultiPrecision <N> t = Sqrt(PI) * ((40320 + w * (3360 + w * (588 + w * 127))) / 80640);
return(x * t);
}
if (x.Exponent < -1)
{
return(InverseErfRootFinding(x));
}
else
{
return(InverseErfcRootFinding(1 - x));
}
}
public void ConvergenceSearchTest1()
{
MultiPrecision <Pow2.N4> ramp(long x, long a) => Math.Min(0, x - a);
for (long a = -50; a <= 450; a++)
{
Console.WriteLine($"a = {a}");
ConvergenceSearch <Pow2.N4> search = new ConvergenceSearch <Pow2.N4>((100, 200), (0, 400));
while (!search.IsSearched)
{
foreach (long sample_point in search.SampleRequests)
{
MultiPrecision <Pow2.N4> sample = ramp(sample_point, a);
search.PushSampleResult(sample_point, sample);
Console.WriteLine($"sample {sample_point}, {sample}");
}
Console.WriteLine($"step {search.Step}, convpoint {search.ConvergencePoint}\n");
search.ReflashSampleRequests();
}
Assert.AreEqual(1, search.Step);
Assert.AreEqual(Math.Min(400, Math.Max(0, a)), search.ConvergencePoint);
}
}
public static (MultiPrecision <N>[] cs, MultiPrecision <N>[] ds) Table(MultiPrecision <N> nu, MultiPrecision <N>[][] dss)
{
int m = dss.Length - 1;
MultiPrecision <N> squa_nu = nu * nu;
MultiPrecision <N>[] cs = new MultiPrecision <N> [m + 1], ds = new MultiPrecision <N> [m + 1];
for (int i = 0; i <= m; i++)
{
MultiPrecision <N> d = dss[i][i], c = 0;
for (int l = 0; l < i; l++)
{
d *= MultiPrecision <N> .Square(m - l + MultiPrecision <N> .Point5) - squa_nu;
}
MultiPrecision <N> u = 1;
for (int j = 0; j <= i; j++)
{
c += dss[i][j] * u;
u *= squa_nu;
}
cs[i] = c;
ds[i] = d;
}
return(cs, ds);
}
public void ToStringFormatTest()
{
MultiPrecision <Pow2.N8> v = MultiPrecision <Pow2.N8> .PI;
Console.WriteLine(v.ToString());
Console.WriteLine($"{v:E10}");
Console.WriteLine(v.ToString("e10"));
Console.WriteLine($"{v: E10}");
Console.WriteLine(v.ToString(" e10"));
Console.WriteLine(v.ToString("e10 "));
Console.WriteLine(v.ToString("e" + MultiPrecision <Pow2.N8> .DecimalDigits));
Assert.ThrowsException <FormatException>(() => {
Console.WriteLine($"{v:E-1}");
});
Assert.ThrowsException <FormatException>(() => {
Console.WriteLine($"{v:E0}");
});
Assert.ThrowsException <FormatException>(() => {
Console.WriteLine($"{v:F10}");
});
Assert.ThrowsException <ArgumentOutOfRangeException>(() => {
Console.WriteLine(v.ToString("e" + MultiPrecision <Pow2.N8> .DecimalDigits + 1));
});
}
public void SinhBorderTest()
{
MultiPrecision <Pow2.N8>[] borders = new MultiPrecision <Pow2.N8>[] { -1, 0, 1 };
foreach (MultiPrecision <Pow2.N8> b in borders)
{
List <MultiPrecision <Pow2.N8> > ys = new();
foreach (MultiPrecision <Pow2.N8> x in TestTool.EnumerateNeighbor(b))
{
MultiPrecision <Pow2.N8> y = MultiPrecision <Pow2.N8> .Sinh(x);
Console.WriteLine(x);
Console.WriteLine(x.ToHexcode());
Console.WriteLine(y);
Console.WriteLine(y.ToHexcode());
Console.Write("\n");
TestTool.Tolerance(Math.Sinh((double)x), y);
ys.Add(y);
}
if (b != 0)
{
TestTool.NearlyNeighbors(ys, 2);
}
TestTool.SmoothnessSatisfied(ys, 1);
TestTool.MonotonicitySatisfied(ys);
Console.Write("\n");
}
}
public void BitIncrementTest()
{
MultiPrecision <Pow2.N8>[] vs =
{
MultiPrecision <Pow2.N8> .NegativeInfinity,
MultiPrecision <Pow2.N8> .MinValue,
"-1e100",
"-1e-100",
-MultiPrecision <Pow2.N8> .Epsilon,
MultiPrecision <Pow2.N8> .MinusZero,
MultiPrecision <Pow2.N8> .Zero,
MultiPrecision <Pow2.N8> .Epsilon,
"1e-100",
"1e100",
MultiPrecision <Pow2.N8> .MaxValue,
MultiPrecision <Pow2.N8> .PositiveInfinity
};
foreach (var v in vs)
{
var vinc = MultiPrecision <Pow2.N8> .BitIncrement(v);
Console.WriteLine(v);
Console.WriteLine(vinc);
Console.WriteLine(v.ToHexcode());
Console.WriteLine(vinc.ToHexcode());
Console.Write("\n");
}
}
public void ErfLargeValueTest()
{
for (decimal z = 2; z <= 20; z += 0.125m)
{
MultiPrecision <Pow2.N8> y_n8 = MultiPrecision <Pow2.N8> .Erf(z);
MultiPrecision <Pow2.N16> y_n16 = MultiPrecision <Pow2.N16> .Erf(z);
MultiPrecision <Pow2.N8> y_n8_m = 1 - MultiPrecision <Pow2.N8> .Erfc(z);
MultiPrecision <Pow2.N16> y_n16_m = 1 - MultiPrecision <Pow2.N16> .Erfc(z);
Console.WriteLine($"erf({z})=");
Console.WriteLine(y_n8);
Console.WriteLine(y_n16);
Console.WriteLine(y_n8.ToHexcode());
Console.WriteLine(y_n16.ToHexcode());
Console.WriteLine(y_n8_m.ToHexcode());
Console.WriteLine(y_n16_m.ToHexcode());
Assert.IsTrue(MultiPrecision <Pow2.N8> .NearlyEqualBits(y_n8, y_n8_m, 1));
Assert.IsTrue(MultiPrecision <Pow2.N16> .NearlyEqualBits(y_n16, y_n16_m, 1));
}
}
public static void Tolerance <N>(double expected, MultiPrecision <N> actual, double minerr = 1e-10, double rateerr = 1e-8, bool ignore_expected_nan = false, bool ignore_sign = false) where N : struct, IConstant
{
if (double.IsNaN(expected))
{
if (!ignore_expected_nan)
{
Assert.IsTrue(actual.IsNaN, "unmatch nan");
}
return;
}
if (!ignore_sign)
{
Assert.AreEqual(Math.Sign(expected), Math.Sign((double)actual), "unmatch sign");
}
if (double.IsInfinity(expected))
{
Assert.IsTrue(double.IsInfinity(actual.ToDouble()), "not infinity");
return;
}
double delta = minerr + Math.Abs(expected) * rateerr;
Assert.AreEqual(expected, (double)actual, delta);
}
public void DigammaUnnormalValueTest()
{
MultiPrecision <Pow2.N8>[] nans = new MultiPrecision <Pow2.N8>[] {
MultiPrecision <Pow2.N8> .NaN,
0
- 1,
-2,
MultiPrecision <Pow2.N8> .NegativeInfinity
};
foreach (MultiPrecision <Pow2.N8> v in nans)
{
MultiPrecision <Pow2.N8> y = MultiPrecision <Pow2.N8> .Digamma(v);
Assert.IsTrue(y.IsNaN);
}
MultiPrecision <Pow2.N8>[] infs = new MultiPrecision <Pow2.N8>[] {
MultiPrecision <Pow2.N8> .PositiveInfinity,
};
foreach (MultiPrecision <Pow2.N8> v in infs)
{
MultiPrecision <Pow2.N8> y = MultiPrecision <Pow2.N8> .Digamma(v);
Assert.AreEqual(MultiPrecision <Pow2.N8> .PositiveInfinity, y);
}
}
public static MultiPrecision <N> Expm1(MultiPrecision <N> x)
{
if (x.Exponent >= 0)
{
return(Exp(x) - 1);
}
MultiPrecision <Plus1 <N> > x_expand = x.Convert <Plus1 <N> >();
MultiPrecision <Plus1 <N> > z = x_expand;
MultiPrecision <Plus1 <N> > y = MultiPrecision <Plus1 <N> > .Zero;
foreach (MultiPrecision <Plus1 <N> > t in MultiPrecision <Plus1 <N> > .TaylorSequence)
{
MultiPrecision <Plus1 <N> > dy = t * z;
y += dy;
if (dy.IsZero || y.Exponent - dy.Exponent > Bits)
{
break;
}
z *= x_expand;
}
return(y.Convert <N>());
}
public void RandomTest()
{
Random random = new Random(1234);
MultiPrecision <Pow2.N8>[] vs = (new MultiPrecision <Pow2.N8> [1000]).Select((v) => MultiPrecision <Pow2.N8> .Random(random)).ToArray();
//foreach (var v in vs) {
// Console.WriteLine(v);
//}
MultiPrecision <Pow2.N8> vs_sum = vs.Sum();
MultiPrecision <Pow2.N8> vs_average = vs.Average();
Console.WriteLine($"sum : {vs_sum}");
Console.WriteLine($"average : {vs_average}");
MultiPrecision <Pow2.N8>[] vs_sorted = vs.OrderBy((v) => v).ToArray();
Console.WriteLine($"median : {vs_sorted[vs.Length / 2]}");
MultiPrecision <Pow2.N8> vs_min = vs.Min();
Console.WriteLine($"min : {vs_min}");
MultiPrecision <Pow2.N8> vs_max = vs.Max();
Console.WriteLine($"min : {vs_max}");
Assert.IsTrue(vs_min >= 0);
Assert.IsTrue(vs_max < 1);
Assert.IsTrue(MultiPrecision <Pow2.N8> .NearlyEquals(vs_average, 0.5, 1e-2));
}
public static MultiPrecision <N> Log1p(MultiPrecision <N> x)
{
const int exp_threshold = 2;
if (x.Exponent >= -exp_threshold)
{
return(MultiPrecision <Plus1 <N> > .Log(1 + x.Convert <Plus1 <N> >()).Convert <N>());
}
MultiPrecision <Plus1 <N> > x_expand = x.Convert <Plus1 <N> >();
MultiPrecision <Plus1 <N> > w = x_expand * x_expand;
MultiPrecision <Plus1 <N> > y = x_expand;
MultiPrecision <Plus1 <N> > z = w;
MultiPrecision <Plus1 <N> > s = x_expand - 1;
for (long i = 2, f = 2; i < Bits; i += exp_threshold * 2, f += 2)
{
MultiPrecision <Plus1 <N> > dy = z * (s * f - 1) / checked (f * (f + 1));
y += dy;
if (dy.IsZero || y.Exponent - dy.Exponent > Bits)
{
break;
}
z *= w;
}
return(y.Convert <N>());
}
public static IEnumerable <MultiPrecision <N> > EnumerateNeighbor <N>(MultiPrecision <N> v, int n = 10) where N : struct, IConstant
{
List <MultiPrecision <N> > vs = new List <MultiPrecision <N> >();
MultiPrecision <N> u = v;
for (int i = 0; i < n; i++)
{
u = MultiPrecision <N> .BitDecrement(u);
vs.Add(u);
}
vs.Reverse();
vs.Add(v);
u = v;
for (int i = 0; i < n; i++)
{
u = MultiPrecision <N> .BitIncrement(u);
vs.Add(u);
}
return(vs);
}
public static MultiPrecision <N> Erfc(MultiPrecision <N> z, long frac_n)
{
MultiPrecision <N> c = z * MultiPrecision <N> .Exp(-z *z) / MultiPrecision <N> .Sqrt(MultiPrecision <N> .PI);
MultiPrecision <N> f = Frac(z, frac_n);
return(c * f);
}
public void LogDiffTest()
{
(MultiPrecision <Pow2.N4> actual, MultiPrecision <Pow2.N4> error) = MultiPrecisionUtil.FiniteDifference <Pow2.N4>(MultiPrecision <Pow2.N4> .Log, 1);
MultiPrecision <Pow2.N4> expected = 1;
Assert.IsTrue(MultiPrecision <Pow2.N4> .NearlyEqualBits(expected, actual, 16));
}
public void SinIntegrateTest()
{
(MultiPrecision <Pow2.N4> actual, _) = MultiPrecisionUtil.RombergIntegrate <Pow2.N4>(MultiPrecision <Pow2.N4> .SinPI, 0, 1);
MultiPrecision <Pow2.N4> expected = 2 / MultiPrecision <Pow2.N4> .PI;
Assert.IsTrue(MultiPrecision <Pow2.N4> .NearlyEqualBits(expected, actual, 1));
}
public void LogIntegrateTest()
{
(MultiPrecision <Pow2.N4> actual, _) = MultiPrecisionUtil.RombergIntegrate <Pow2.N4>(MultiPrecision <Pow2.N4> .Log, 1, 2);
MultiPrecision <Pow2.N4> expected = 2 * MultiPrecision <Pow2.N4> .Log(2) - 1;
Assert.IsTrue(MultiPrecision <Pow2.N4> .NearlyEqualBits(expected, actual, 1));
}
public void PolyIntegrateTest()
{
(MultiPrecision <Pow2.N4> actual, _) = MultiPrecisionUtil.RombergIntegrate <Pow2.N4>(MultiPrecision <Pow2.N4> .Square, 0, 1);
MultiPrecision <Pow2.N4> expected = MultiPrecision <Pow2.N4> .One / 3;
Assert.IsTrue(MultiPrecision <Pow2.N4> .NearlyEqualBits(expected, actual, 1));
}
public void ZeroIntegrateTest()
{
(MultiPrecision <Pow2.N4> actual, _) = MultiPrecisionUtil.RombergIntegrate <Pow2.N4>(MultiPrecision <Pow2.N4> .Cube, -1, 1);
MultiPrecision <Pow2.N4> expected = 0;
Assert.IsTrue(MultiPrecision <Pow2.N4> .NearlyEqualBits(expected, actual, 1));
}
public void ExpIntegrateTest()
{
(MultiPrecision <Pow2.N4> actual, _) = MultiPrecisionUtil.RombergIntegrate <Pow2.N4>(MultiPrecision <Pow2.N4> .Exp, 1, 2);
MultiPrecision <Pow2.N4> expected = MultiPrecision <Pow2.N4> .E * (MultiPrecision <Pow2.N4> .E - 1);
Assert.IsTrue(MultiPrecision <Pow2.N4> .NearlyEqualBits(expected, actual, 1));
}
