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)); }