public void Bukin() { // Burkin has a narrow valley, not aligned with any axis, punctuated with many tiny "wells" along its bottom. // The deepest well is at (-10,1)-> 0. Func <IList <double>, double> function = (IList <double> x) => 100.0 * Math.Sqrt(Math.Abs(x[1] - 0.01 * x[0] * x[0])) + 0.01 * Math.Abs(x[0] + 10.0); IList <Interval> box = new Interval[] { Interval.FromEndpoints(-15.0, 0.0), Interval.FromEndpoints(-3.0, 3.0) }; EvaluationSettings settings = new EvaluationSettings() { RelativePrecision = 0.0, AbsolutePrecision = 1.0E-4, EvaluationBudget = 1000000 }; /* * settings.Update += (object result) => { * MultiExtremum e = (MultiExtremum) result; * Console.WriteLine("After {0} evaluations, best value {1}", e.EvaluationCount, e.Value); * }; */ MultiExtremum minimum = MultiFunctionMath.FindGlobalMinimum(function, box, settings); Console.WriteLine(minimum.EvaluationCount); Console.WriteLine("{0} ({1})", minimum.Value, minimum.Precision); Console.WriteLine("{0} {1}", minimum.Location[0], minimum.Location[1]); // We do not end up finding the global minimum. }
public void EllipticKIntegrals() { Interval i = Interval.FromEndpoints(0.0, 1.0); // http://mathworld.wolfram.com/CatalansConstant.html equation 37 Assert.IsTrue(TestUtilities.IsNearlyEqual( FunctionMath.Integrate( k => AdvancedMath.EllipticK(k), Interval.FromEndpoints(0.0, 1.0)), 2.0 * AdvancedMath.Catalan )); Assert.IsTrue(TestUtilities.IsNearlyEqual( FunctionMath.Integrate( k => AdvancedMath.EllipticK(k) * k, Interval.FromEndpoints(0.0, 1.0)), 1.0 )); Assert.IsTrue(TestUtilities.IsNearlyEqual( FunctionMath.Integrate( k => AdvancedMath.EllipticK(k) / (1.0 + k), Interval.FromEndpoints(0.0, 1.0)), Math.PI * Math.PI / 8.0 )); }
public void FitToFunctionPolynomialCompatibilityTest() { // specify a cubic function Interval r = Interval.FromEndpoints(-10.0, 10.0); Func <double, double> fv = delegate(double x) { return(0.0 - 1.0 * x + 2.0 * x * x - 3.0 * x * x * x); }; Func <double, double> fu = delegate(double x) { return(1.0 + 0.5 * Math.Cos(x)); }; // create a data set from it UncertainMeasurementSample set = CreateDataSet(r, fv, fu, 60); // fit it to a cubic polynomial UncertainMeasurementFitResult pFit = set.FitToPolynomial(3); // fit it to a cubic polynomial Func <double[], double, double> ff = delegate(double[] p, double x) { return(p[0] + p[1] * x + p[2] * x * x + p[3] * x * x * x); }; UncertainMeasurementFitResult fFit = set.FitToFunction(ff, new double[] { 0, 0, 0, 0 }); // dimension Assert.IsTrue(pFit.Parameters.Count == fFit.Parameters.Count); // chi squared Assert.IsTrue(TestUtilities.IsNearlyEqual(pFit.GoodnessOfFit.Statistic, fFit.GoodnessOfFit.Statistic, Math.Sqrt(TestUtilities.TargetPrecision))); // don't demand super-high precision agreement of parameters and covariance matrix // parameters Assert.IsTrue(TestUtilities.IsNearlyEqual(pFit.Parameters.ValuesVector, fFit.Parameters.ValuesVector, Math.Pow(TestUtilities.TargetPrecision, 0.3))); // covariance Assert.IsTrue(TestUtilities.IsNearlyEqual(pFit.Parameters.CovarianceMatrix, fFit.Parameters.CovarianceMatrix, Math.Pow(TestUtilities.TargetPrecision, 0.3))); }
public void FitDataToLinearFunctionTest() { // create a data set from a linear combination of sine and cosine Interval r = Interval.FromEndpoints(-4.0, 6.0); double[] c = new double[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 }; Func <double, double> fv = delegate(double x) { return(2.0 * Math.Cos(x) + 1.0 * Math.Sin(x)); }; Func <double, double> fu = delegate(double x) { return(0.1 + 0.1 * Math.Abs(x)); }; UncertainMeasurementSample set = CreateDataSet(r, fv, fu, 20, 2); // fit the data set to a linear combination of sine and cosine Func <double, double>[] fs = new Func <double, double>[] { delegate(double x) { return(Math.Cos(x)); }, delegate(double x) { return(Math.Sin(x)); } }; FitResult result = set.FitToLinearFunction(fs); // the fit should be right right dimension Assert.IsTrue(result.Dimension == 2); // the coefficients should match Console.WriteLine(result.Parameter(0)); Console.WriteLine(result.Parameter(1)); Assert.IsTrue(result.Parameter(0).ConfidenceInterval(0.95).ClosedContains(2.0)); Assert.IsTrue(result.Parameter(1).ConfidenceInterval(0.95).ClosedContains(1.0)); // diagonal covarainces should match errors Assert.IsTrue(TestUtilities.IsNearlyEqual(Math.Sqrt(result.Covariance(0, 0)), result.Parameter(0).Uncertainty)); Assert.IsTrue(TestUtilities.IsNearlyEqual(Math.Sqrt(result.Covariance(1, 1)), result.Parameter(1).Uncertainty)); }
public void TestBivariateRegression() { // Do a bunch of linear regressions. r^2 should be distributed as expected. double a0 = 1.0; double b0 = 0.0; Random rng = new Random(1001110000); ContinuousDistribution xDistribution = new UniformDistribution(Interval.FromEndpoints(-2.0, 4.0)); ContinuousDistribution eDistribution = new NormalDistribution(); List <double> r2Sample = new List <double>(); for (int i = 0; i < 500; i++) { BivariateSample xySample = new BivariateSample(); for (int k = 0; k < 10; k++) { double x = xDistribution.GetRandomValue(rng); double y = a0 + b0 * x + eDistribution.GetRandomValue(rng); xySample.Add(x, y); } LinearRegressionResult fit = xySample.LinearRegression(); double a = fit.Intercept.Value; double b = fit.Slope.Value; r2Sample.Add(fit.RSquared); } ContinuousDistribution r2Distribution = new BetaDistribution((2 - 1) / 2.0, (10 - 2) / 2.0); TestResult ks = r2Sample.KolmogorovSmirnovTest(r2Distribution); Assert.IsTrue(ks.Probability > 0.05); }
public void EllipticKCatalanIntegral() { System.Diagnostics.Stopwatch timer = System.Diagnostics.Stopwatch.StartNew(); Interval i = Interval.FromEndpoints(0.0, 1.0); // http://mathworld.wolfram.com/CatalansConstant.html equation 37 Func <double, double> f1 = delegate(double k) { return(AdvancedMath.EllipticK(k)); }; Assert.IsTrue(TestUtilities.IsNearlyEqual( FunctionMath.Integrate(f1, i), 2.0 * AdvancedMath.Catalan )); Func <double, double> f2 = delegate(double k) { return(AdvancedMath.EllipticK(k) * k); }; Assert.IsTrue(TestUtilities.IsNearlyEqual( FunctionMath.Integrate(f2, i), 1.0 )); timer.Stop(); Console.WriteLine(timer.ElapsedTicks); }
public void RootOfEi() { double x = FunctionMath.FindZero(AdvancedMath.IntegralEi, Interval.FromEndpoints(0.1, 1.0)); Assert.IsTrue(TestUtilities.IsNearlyEqual(x, 0.37250741078136663446)); Assert.IsTrue(Math.Abs(AdvancedMath.IntegralEi(x)) < TestUtilities.TargetPrecision); }
public void ThompsonGlobal() { for (int n = 2; n < 8; n++) { Console.WriteLine("n={0}", n); Func <IList <double>, double> f = GetThompsonFunction(n); Interval[] box = new Interval[2 * (n - 1)]; for (int i = 0; i < (n - 1); i++) { box[2 * i] = Interval.FromEndpoints(-Math.PI, Math.PI); box[2 * i + 1] = Interval.FromEndpoints(-Math.PI / 2.0, Math.PI / 2.0); } MultiExtremum minimum = MultiFunctionMath.FindGlobalMinimum(f, box); Console.WriteLine(minimum.EvaluationCount); Console.WriteLine("{0} ({1})", minimum.Value, minimum.Precision); for (int i = 0; i < (n - 1); i++) { Console.WriteLine("{0} {1}", minimum.Location[2 * i], minimum.Location[2 * i + 1]); } Console.WriteLine("0.0 0.0"); Assert.IsTrue(minimum.Dimension == 2 * (n - 1)); Assert.IsTrue(TestUtilities.IsNearlyEqual(minimum.Value, thompsonSolutions[n], new EvaluationSettings() { AbsolutePrecision = 2.0 * minimum.Precision })); } }
public void FindExtremaNegativeGamma() { // https://en.wikipedia.org/wiki/Particular_values_of_the_Gamma_function#Other_constants Tuple <double, double>[] extrema = new Tuple <double, double>[] { Tuple.Create(-0.5040830082644554092582693045, -3.5446436111550050891219639933), Tuple.Create(-1.5734984731623904587782860437, 2.3024072583396801358235820396), Tuple.Create(-2.6107208684441446500015377157, -0.8881363584012419200955280294), Tuple.Create(-3.6352933664369010978391815669, 0.2451275398343662504382300889) }; foreach (Tuple <double, double> extremum in extrema) { // We use brackets since we know the extremum must lie between the singularities. // We should be able to use the actual singularities at endpoints, but this doesn't work; look into it. Interval bracket = Interval.FromEndpoints(Math.Floor(extremum.Item1) + 0.01, Math.Ceiling(extremum.Item1) - 0.01); Extremum result; if (extremum.Item2 < 0.0) { result = FunctionMath.FindMaximum(AdvancedMath.Gamma, bracket); } else { result = FunctionMath.FindMinimum(AdvancedMath.Gamma, bracket); } Assert.IsTrue(result.Bracket.OpenContains(extremum.Item1)); Assert.IsTrue(result.Bracket.OpenContains(result.Location)); Assert.IsTrue(TestUtilities.IsNearlyEqual(result.Value, extremum.Item2)); } }
public void WatsonIntegrals() { // Watson defined and analytically integrated three complicated triple integrals related to random walks in three dimension // See http://mathworld.wolfram.com/WatsonsTripleIntegrals.html Interval watsonWidth = Interval.FromEndpoints(0.0, Math.PI); Interval[] watsonBox = new Interval[] { watsonWidth, watsonWidth, watsonWidth }; Assert.IsTrue( MultiFunctionMath.Integrate( (IReadOnlyList <double> x) => 1.0 / (1.0 - Math.Cos(x[0]) * Math.Cos(x[1]) * Math.Cos(x[2])), watsonBox ).Estimate.ConfidenceInterval(0.99).ClosedContains( MoreMath.Pow(AdvancedMath.Gamma(1.0 / 4.0), 4) / 4.0 ) ); Assert.IsTrue( MultiFunctionMath.Integrate( (IReadOnlyList <double> x) => 1.0 / (3.0 - Math.Cos(x[0]) * Math.Cos(x[1]) - Math.Cos(x[1]) * Math.Cos(x[2]) - Math.Cos(x[0]) * Math.Cos(x[2])), watsonBox ).Estimate.ConfidenceInterval(0.99).ClosedContains( 3.0 * MoreMath.Pow(AdvancedMath.Gamma(1.0 / 3.0), 6) / Math.Pow(2.0, 14.0 / 3.0) / Math.PI ) ); Assert.IsTrue( MultiFunctionMath.Integrate( (IReadOnlyList <double> x) => 1.0 / (3.0 - Math.Cos(x[0]) - Math.Cos(x[1]) - Math.Cos(x[2])), watsonBox ).Estimate.ConfidenceInterval(0.99).ClosedContains( Math.Sqrt(6.0) / 96.0 * AdvancedMath.Gamma(1.0 / 24.0) * AdvancedMath.Gamma(5.0 / 24.0) * AdvancedMath.Gamma(7.0 / 24.0) * AdvancedMath.Gamma(11.0 / 24.0) ) ); }
public void JacobiIntegrals() { foreach (double k in TestUtilities.GenerateRealValues(1.0E-1, 1.0, 4)) { // DLMF 22.14.18 says // \int_{0}^{K(k)} \ln(\dn(t, k)) \, dt = \frac{1}{2} K(k) \ln k' double K = AdvancedMath.EllipticK(k); double k1 = Math.Sqrt(1.0 - k * k); double I1 = FunctionMath.Integrate( x => Math.Log(AdvancedMath.JacobiDn(x, k)), Interval.FromEndpoints(0.0, K) ); Assert.IsTrue(TestUtilities.IsNearlyEqual(I1, K / 2.0 * Math.Log(k1))); // If k is small, log(k1) is subject to cancellation error, so don't pick k too small. // It also gives values for the analogous integrals with \sn and \cn, // but their values involve K'(k), for which we don't have a method. // Mathworld (http://mathworld.wolfram.com/CompleteEllipticIntegraloftheSecondKind.html) says // \int_{0}^{K(k)} \dn^2(t, k) = E(k) double I2 = FunctionMath.Integrate( u => MoreMath.Sqr(AdvancedMath.JacobiDn(u, k)), Interval.FromEndpoints(0.0, K) ); Assert.IsTrue(TestUtilities.IsNearlyEqual(I2, AdvancedMath.EllipticE(k))); } }
public void HypergeometricIntegral() { // A&S 15.3.1 // F(a, b, c, x) = \frac{\Gamma(c)}{\Gamma(b) \Gamma(c - b)} // \int_{0}^{1} \! dt \, t^{b-1} (1 - t)^{c - b - 1} (1 - x t)^{-a} // Choose limits on a, b, c so that singularities of integrand are numerically integrable. foreach (double a in TestUtilities.GenerateRealValues(1.0, 10.0, 2)) { foreach (double b in TestUtilities.GenerateRealValues(0.6, 10.0, 2)) { foreach (double c in TestUtilities.GenerateRealValues(b + 0.6, 10.0, 2)) { foreach (double x in xs) { double I = FunctionMath.Integrate( t => Math.Pow(t, b - 1.0) * Math.Pow(1.0 - t, c - b - 1.0) * Math.Pow(1.0 - x * t, -a), Interval.FromEndpoints(0.0, 1.0) ); double B = AdvancedMath.Beta(b, c - b); Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedMath.Hypergeometric2F1(a, b, c, x), I / B)); } } } } }
public void IntervalMidpoint() { Interval ab = Interval.FromEndpoints(a, b); Assert.IsTrue(ab.Midpoint == (a + b) / 2.0); Assert.IsTrue(ab.Contains(ab.Midpoint)); }
public void FitDataToProportionalityTest() { Interval r = Interval.FromEndpoints(0.0, 0.1); Func <double, double> fv = delegate(double x) { return(0.5 * x); }; Func <double, double> fu = delegate(double x) { return(0.02); }; UncertainMeasurementSample set = CreateDataSet(r, fv, fu, 20); // fit to proportionality FitResult prop = set.FitToProportionality(); Assert.IsTrue(prop.Dimension == 1); Assert.IsTrue(prop.Parameter(0).ConfidenceInterval(0.95).ClosedContains(0.5)); Assert.IsTrue(prop.GoodnessOfFit.LeftProbability < 0.95); // fit to line FitResult line = set.FitToLine(); Assert.IsTrue(line.Dimension == 2); // line's intercept should be compatible with zero and slope with proportionality constant Assert.IsTrue(line.Parameter(0).ConfidenceInterval(0.95).ClosedContains(0.0)); Assert.IsTrue(line.Parameter(1).ConfidenceInterval(0.95).ClosedContains(prop.Parameter(0).Value)); // the fit should be better, but not too much better Assert.IsTrue(line.GoodnessOfFit.Statistic < prop.GoodnessOfFit.Statistic); }
public void MultivariateLinearRegressionAgreement2() { // A multivariate linear regression with just one x-column should be the same as a bivariate linear regression. double intercept = 1.0; double slope = -2.0; ContinuousDistribution yErrDist = new NormalDistribution(0.0, 3.0); UniformDistribution xDist = new UniformDistribution(Interval.FromEndpoints(-2.0, 3.0)); Random rng = new Random(1111111); MultivariateSample multi = new MultivariateSample("x", "y"); for (int i = 0; i < 10; i++) { double x = xDist.GetRandomValue(rng); double y = intercept + slope * x + yErrDist.GetRandomValue(rng); multi.Add(x, y); } // Old multi linear regression code. MultiLinearRegressionResult result1 = multi.LinearRegression(1); // Simple linear regression code. LinearRegressionResult result2 = multi.TwoColumns(0, 1).LinearRegression(); Assert.IsTrue(TestUtilities.IsNearlyEqual(result1.Parameters["Intercept"].Estimate, result2.Parameters["Intercept"].Estimate)); // New multi linear regression code. MultiLinearRegressionResult result3 = multi.Column(1).ToList().MultiLinearRegression(multi.Column(0).ToList()); Assert.IsTrue(TestUtilities.IsNearlyEqual(result1.Parameters["Intercept"].Estimate, result3.Parameters["Intercept"].Estimate)); }
public void AssociatedLegendreOrthonormalityL() { // don't let l and m get too big, or numerical integration will fail due to heavily oscilatory behavior int[] ells = TestUtilities.GenerateIntegerValues(1, 10, 4); for (int ki = 0; ki < ells.Length; ki++) { int k = ells[ki]; for (int li = 0; li <= ki; li++) { int l = ells[li]; foreach (int m in TestUtilities.GenerateUniformIntegerValues(0, Math.Min(k, l), 4)) { Func <double, double> f = delegate(double x) { return(OrthogonalPolynomials.LegendreP(k, m, x) * OrthogonalPolynomials.LegendreP(l, m, x)); }; double I = FunctionMath.Integrate(f, Interval.FromEndpoints(-1.0, 1.0)); Console.WriteLine("k={0} l={1} m={2} I={3}", k, l, m, I); if (k == l) { Assert.IsTrue(TestUtilities.IsNearlyEqual( I, 2.0 / (2 * k + 1) * Math.Exp(AdvancedIntegerMath.LogFactorial(l + m) - AdvancedIntegerMath.LogFactorial(l - m)) )); } else { Assert.IsTrue(Math.Abs(I) < TestUtilities.TargetPrecision); } } } } }
public void FitDataToPolynomialChiSquaredTest() { // we want to make sure that the chi^2 values we are producing from polynomial fits are distributed as expected // create a sample to hold chi^2 values Sample chis = new Sample(); // define a model Interval r = Interval.FromEndpoints(-5.0, 15.0); Func <double, double> fv = delegate(double x) { return(1.0 * x - 2.0 * x * x); }; Func <double, double> fu = delegate(double x) { return(1.0 + 0.5 * Math.Sin(x)); }; // draw 50 data sets from the model and fit year // store the resulting chi^2 value in the chi^2 set for (int i = 0; i < 50; i++) { UncertainMeasurementSample xs = CreateDataSet(r, fv, fu, 10, i); FitResult fit = xs.FitToPolynomial(2); double chi = fit.GoodnessOfFit.Statistic; chis.Add(chi); } // sanity check the sample Assert.IsTrue(chis.Count == 50); // test whether the chi^2 values are distributed as expected ContinuousDistribution chiDistribution = new ChiSquaredDistribution(7); TestResult ks = chis.KolmogorovSmirnovTest(chiDistribution); Assert.IsTrue(ks.LeftProbability < 0.95); }
public void IntervalEndpoints() { Interval ab = Interval.FromEndpoints(a, b); Assert.IsTrue(ab.LeftEndpoint == a); Assert.IsTrue(ab.RightEndpoint == b); }
public void IntervalZeroWidth() { Interval aa = Interval.FromEndpoints(a, a); Assert.IsTrue(aa.Width == 0.0); Assert.IsTrue(aa.LeftEndpoint == aa.RightEndpoint); Assert.IsTrue(aa.Midpoint == a); }
public void RootOfJ0() { Func <double, double> f = delegate(double x) { return(AdvancedMath.BesselJ(0, x)); }; double y = FunctionMath.FindZero(f, Interval.FromEndpoints(2.0, 4.0)); Assert.IsTrue(TestUtilities.IsNearlyEqual(y, 2.40482555769577276862)); }
// Returns a d-dimensional symmetric unit cube [-1,+1]^d public Interval[] SymmetricUnitCube(int d) { Interval[] box = new Interval[d]; for (int j = 0; j < d; j++) { box[j] = Interval.FromEndpoints(-1.0, 1.0); } return(box); }
public void BesselWeberIntegral() { Func <double, double> f = delegate(double t) { return(Math.Exp(-t * t) * AdvancedMath.BesselJ(0, t) * t); }; Interval r = Interval.FromEndpoints(0.0, Double.PositiveInfinity); Assert.IsTrue(TestUtilities.IsNearlyEqual(FunctionMath.Integrate(f, r).Estimate.Value, Math.Exp(-1.0 / 4.0) / 2.0)); }
public void IntervalClosedContains() { Interval ac = Interval.FromEndpoints(a, c); Assert.IsTrue(ac.ClosedContains(a)); Assert.IsTrue(ac.ClosedContains(c)); Assert.IsTrue(ac.ClosedContains(b)); Assert.IsFalse(ac.ClosedContains(d)); }
public void MultivariateLinearRegressionSimple() { // define model y = a + b0 * x0 + b1 * x1 + noise double a = 1.0; double b0 = -2.0; double b1 = 3.0; ContinuousDistribution x0distribution = new CauchyDistribution(10.0, 5.0); ContinuousDistribution x1distribution = new UniformDistribution(Interval.FromEndpoints(-10.0, 20.0)); ContinuousDistribution noise = new NormalDistribution(0.0, 10.0); // draw a sample from the model Random rng = new Random(1); MultivariateSample sample = new MultivariateSample("x0", "x1", "y"); FrameTable table = new FrameTable(); table.AddColumns <double>("x0", "x1", "y"); for (int i = 0; i < 100; i++) { double x0 = x0distribution.GetRandomValue(rng); double x1 = x1distribution.GetRandomValue(rng); double eps = noise.GetRandomValue(rng); double y = a + b0 * x0 + b1 * x1 + eps; sample.Add(x0, x1, y); table.AddRow(x0, x1, y); } // do a linear regression fit on the model ParameterCollection oldResult = sample.LinearRegression(2).Parameters; MultiLinearRegressionResult newResult = table["y"].As <double>().MultiLinearRegression( table["x0"].As <double>(), table["x1"].As <double>() ); // the result should have the appropriate dimension Assert.IsTrue(oldResult.Count == 3); Assert.IsTrue(newResult.Parameters.Count == 3); // The parameters should match the model Assert.IsTrue(oldResult[0].Estimate.ConfidenceInterval(0.90).ClosedContains(b0)); Assert.IsTrue(oldResult[1].Estimate.ConfidenceInterval(0.90).ClosedContains(b1)); Assert.IsTrue(oldResult[2].Estimate.ConfidenceInterval(0.90).ClosedContains(a)); Assert.IsTrue(newResult.CoefficientOf(0).ConfidenceInterval(0.99).ClosedContains(b0)); Assert.IsTrue(newResult.CoefficientOf("x1").ConfidenceInterval(0.99).ClosedContains(b1)); Assert.IsTrue(newResult.Intercept.ConfidenceInterval(0.99).ClosedContains(a)); // The residuals should be compatible with the model predictions for (int i = 0; i < table.Rows.Count; i++) { FrameRow row = table.Rows[i]; double x0 = (double)row["x0"]; double x1 = (double)row["x1"]; double yp = newResult.Predict(x0, x1).Value; double y = (double)row["y"]; Assert.IsTrue(TestUtilities.IsNearlyEqual(newResult.Residuals[i], y - yp)); } }
public void IntervalEquality() { Interval ab = Interval.FromEndpoints(a, b); Interval ac = Interval.FromEndpoints(a, c); Assert.IsTrue(ab.Equals(ab)); Assert.IsTrue(ab.Equals((object)ab)); Assert.IsFalse(ab.Equals(ac)); Assert.IsFalse(ab.Equals((object)ac)); }
public void IntegralSiDefinition() { Func <double, double> f = t => Math.Sin(t) / t; foreach (double x in TestUtilities.GenerateRealValues(1.0E-2, 1.0E2, 8)) { Interval r = Interval.FromEndpoints(0.0, x); Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedMath.IntegralSi(x), FunctionMath.Integrate(f, r))); } }
public void BesselLipshitzIntegral() { // \int_{0}^{\infty} e^{-x} J_0(x) \, dx = \frac{1}{\sqrt{2}} Func <double, double> f = delegate(double t) { return(Math.Exp(-t) * AdvancedMath.BesselJ(0, t)); }; Interval r = Interval.FromEndpoints(0.0, Double.PositiveInfinity); Assert.IsTrue(TestUtilities.IsNearlyEqual(FunctionMath.Integrate(f, r).Estimate.Value, 1.0 / Math.Sqrt(2.0))); }
public void GammaIntegral() { foreach (double x in TestUtilities.GenerateRealValues(1.0, 1.0E2, 4)) { Func <double, double> f = delegate(double t) { return(Math.Pow(t, x - 1.0) * Math.Exp(-t)); }; Interval r = Interval.FromEndpoints(0.0, Double.PositiveInfinity); Assert.IsTrue(TestUtilities.IsNearlyEqual(AdvancedMath.Gamma(x), FunctionMath.Integrate(f, r))); } }
public void AiryAiIntegral() { // DLMF 9.10.11 Func <double, double> f = delegate(double t) { return(AdvancedMath.AiryAi(t)); }; Interval r = Interval.FromEndpoints(0.0, Double.PositiveInfinity); double I = FunctionMath.Integrate(f, r); Assert.IsTrue(TestUtilities.IsNearlyEqual(I, 1.0 / 3.0)); }
public void IntervalContainsEndpoints() { Interval ab = Interval.FromEndpoints(a, b); Assert.IsTrue(ab.Contains(a, IntervalType.Closed)); Assert.IsFalse(ab.Contains(a, IntervalType.Open)); Assert.IsTrue(ab.Contains(a, IntervalType.Closed, IntervalType.Open)); Assert.IsTrue(ab.Contains(b, IntervalType.Closed)); Assert.IsFalse(ab.Contains(b, IntervalType.Open)); Assert.IsFalse(ab.Contains(b, IntervalType.Closed, IntervalType.Open)); }