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 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 FitDataToLineUncertaintyTest() { double[] xs = TestUtilities.GenerateUniformRealValues(0.0, 10.0, 10); Func <double, double> fv = delegate(double x) { return(2.0 * x - 1.0); }; Func <double, double> fu = delegate(double x) { return(1.0 + x); }; MultivariateSample sample = new MultivariateSample(2); SymmetricMatrix covariance = new SymmetricMatrix(2); // create a bunch of small data sets for (int i = 0; i < 100; i++) { UncertainMeasurementSample data = CreateDataSet(xs, fv, fu, i); FitResult fit = data.FitToLine(); sample.Add(fit.Parameters); covariance = fit.CovarianceMatrix; // because it depends only on the x's and sigmas, the covariance is always the same Console.WriteLine("cov_00 = {0}", covariance[0, 0]); } // the measured covariances should agree with the claimed covariances //Assert.IsTrue(sample.PopulationCovariance(0,0).ConfidenceInterval(0.95).ClosedContains(covariance[0,0])); //Assert.IsTrue(sample.PopulationCovariance(0,1).ConfidenceInterval(0.95).ClosedContains(covariance[0,1])); //Assert.IsTrue(sample.PopulationCovariance(1,0).ConfidenceInterval(0.95).ClosedContains(covariance[1,0])); //Assert.IsTrue(sample.PopulationCovariance(1,1).ConfidenceInterval(0.95).ClosedContains(covariance[1,1])); }
public void Bug6162() { // When UncertianMeasurementSample.FitToPolynomial used Cholesky inversion of (A^T A), this inversion // would fail when roundoff errors would made the matrix non-positive-definite. We have now changed // to QR decomposition, which is more robust. //real data double[] X_axis = new double[] { 40270.65625, 40270.6569444444, 40270.6576388888, 40270.6583333332, 40270.6590277776, 40270.659722222, 40270.6604166669, 40270.6611111113, 40270.6618055557, 40270.6625000001 }; double[] Y_axis = new double[] { 246.824996948242, 246.850006103516, 245.875, 246.225006103516, 246.975006103516, 247.024993896484, 246.949996948242, 246.875, 247.5, 247.100006103516 }; UncertainMeasurementSample DataSet = new UncertainMeasurementSample(); for (int i = 0; i < 10; i++) { DataSet.Add(X_axis[i], Y_axis[i], 1); } UncertainMeasurementFitResult DataFit = DataSet.FitToPolynomial(3); BivariateSample bs = new BivariateSample(); for (int i = 0; i < 10; i++) { bs.Add(X_axis[i], Y_axis[i]); } PolynomialRegressionResult bsFit = bs.PolynomialRegression(3); foreach (Parameter p in bsFit.Parameters) { Console.WriteLine(p); } }
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 DataSetManipulationsTest() { UncertainMeasurement <double> d1 = new UncertainMeasurement <double>(3.0, new UncertainValue(2.0, 1.0)); UncertainMeasurement <double> d2 = new UncertainMeasurement <double>(-3.0, new UncertainValue(2.0, 1.0)); UncertainMeasurement <double> d3 = new UncertainMeasurement <double>(3.0, new UncertainValue(-2.0, 1.0)); Assert.IsTrue(d1 != null); UncertainMeasurement <double>[] data = new UncertainMeasurement <double>[] { d1, d2 }; UncertainMeasurementSample set = new UncertainMeasurementSample(); set.Add(data); Assert.IsFalse(set.Contains(d3)); Assert.IsTrue(set.Count == data.Length); set.Add(d3); Assert.IsTrue(set.Contains(d3)); Assert.IsTrue(set.Count == data.Length + 1); set.Remove(d3); Assert.IsFalse(set.Contains(d3)); Assert.IsTrue(set.Count == data.Length); set.Clear(); Assert.IsTrue(set.Count == 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 FitDataToPolynomialTest() { Interval r = Interval.FromEndpoints(-10.0, 10.0); double[] c = new double[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 }; Func <double, double> fv = delegate(double x) { double f = 0.0; for (int i = c.Length - 1; i >= 0; i--) { f = f * x + c[i]; } return(f); }; Func <double, double> fu = delegate(double x) { return(1.0 + 0.5 * Math.Cos(x)); }; UncertainMeasurementSample set = CreateDataSet(r, fv, fu, 50); Assert.IsTrue(set.Count == 50); // fit to an appropriate polynomial FitResult poly = set.FitToPolynomial(5); // the coefficients should match for (int i = 0; i < poly.Dimension; i++) { Assert.IsTrue(poly.Parameter(i).ConfidenceInterval(0.95).ClosedContains(c[i])); } // the fit should be good Console.WriteLine(poly.GoodnessOfFit.LeftProbability); Assert.IsTrue(poly.GoodnessOfFit.LeftProbability < 0.95); // fit to a lower order polynomial FitResult low = set.FitToPolynomial(4); // the fit should be bad Assert.IsTrue(low.GoodnessOfFit.Statistic > poly.GoodnessOfFit.Statistic); Assert.IsTrue(low.GoodnessOfFit.LeftProbability > 0.95); // fit to a higher order polynomial FitResult high = set.FitToPolynomial(6); // the higher order coefficients should be compatible with zero Assert.IsTrue(high.Parameter(6).ConfidenceInterval(0.95).ClosedContains(0.0)); // the fit should be better, but not too much better Assert.IsTrue(high.GoodnessOfFit.Statistic < poly.GoodnessOfFit.Statistic); }
private UncertainMeasurementSample CreateDataSet(double[] xs, Func <double, double> fv, Func <double, double> fu, int seed) { UncertainMeasurementSample set = new UncertainMeasurementSample(); Random rng = new Random(seed); foreach (double x in xs) { double ym = fv(x); double ys = fu(x); NormalDistribution yd = new NormalDistribution(ym, ys); double y = yd.InverseLeftProbability(rng.NextDouble()); UncertainMeasurement <double> point = new UncertainMeasurement <double>(x, y, ys); set.Add(point); } return(set); }
public void FitDataToPolynomialUncertaintiesTest() { // make sure the reported uncertainties it fit parameters really represent their standard deviation, // and that the reported off-diagonal elements really represent their correlations double[] xs = TestUtilities.GenerateUniformRealValues(-1.0, 2.0, 10); Func <double, double> fv = delegate(double x) { return(0.0 + 1.0 * x + 2.0 * x * x); }; Func <double, double> fu = delegate(double x) { return(0.5); }; // keep track of best-fit parameters and claimed parameter covariances MultivariateSample sample = new MultivariateSample(3); // generate 50 small data sets and fit each UncertainMeasurementFitResult[] fits = new UncertainMeasurementFitResult[50]; for (int i = 0; i < fits.Length; i++) { UncertainMeasurementSample set = CreateDataSet(xs, fv, fu, 314159 + i); fits[i] = set.FitToPolynomial(2); sample.Add(fits[i].Parameters.ValuesVector); } // check that parameters agree for (int i = 0; i < 3; i++) { Console.WriteLine(sample.Column(i).PopulationMean); } // for each parameter, verify that the standard deviation of the reported values agrees with the (average) reported uncertainty double[] pMeans = new double[3]; for (int i = 0; i <= 2; i++) { Sample values = new Sample(); Sample uncertainties = new Sample(); for (int j = 0; j < fits.Length; j++) { UncertainValue p = fits[j].Parameters[i].Estimate; values.Add(p.Value); uncertainties.Add(p.Uncertainty); } pMeans[i] = values.Mean; Assert.IsTrue(values.PopulationStandardDeviation.ConfidenceInterval(0.95).ClosedContains(uncertainties.Mean)); } }
public void FitDataToFunctionTest() { // create a data set from a nonlinear function /* * Interval r = Interval.FromEndpoints(-3.0, 5.0); * double[] c = new double[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 }; * Function<double, double> fv = delegate(double x) { * return (3.0 * Math.Cos(2.0 * Math.PI * x / 2.0 - 1.0)); * }; * Function<double, double> fu = delegate(double x) { * return (0.1 + 0.1 * Math.Abs(x)); * }; * DataSet set = CreateDataSet(r, fv, fu, 20, 2); */ UncertainMeasurementSample set = new UncertainMeasurementSample(); set.Add(new UncertainMeasurement <double>(1.0, 1.0, 0.1)); set.Add(new UncertainMeasurement <double>(2.0, 0.7, 0.1)); set.Add(new UncertainMeasurement <double>(3.0, 0.0, 0.1)); set.Add(new UncertainMeasurement <double>(4.0, -0.7, 0.1)); set.Add(new UncertainMeasurement <double>(5.0, -1.0, 0.1)); set.Add(new UncertainMeasurement <double>(6.0, -0.7, 0.1)); set.Add(new UncertainMeasurement <double>(7.0, 0.0, 0.1)); set.Add(new UncertainMeasurement <double>(8.0, 0.7, 0.1)); set.Add(new UncertainMeasurement <double>(9.0, 1.0, 0.1)); // fit it to a parameterized fit function /* * Function<double[], double, double> ff = delegate(double[] p, double x) { * return (p[0] * Math.Cos(2.0 * Math.PI / p[1] + p[2])); * }; */ Func <double[], double, double> ff = delegate(double[] p, double x) { //Console.WriteLine(" p[0]={0}, x={1}", p[0], x); return(p[1] * Math.Cos(x / p[0] + p[2])); //return (x / p[0]); }; FitResult fit = set.FitToFunction(ff, new double[] { 1.3, 1.1, 0.1 }); Console.WriteLine(fit.Parameter(0)); Console.WriteLine(fit.Parameter(1)); Console.WriteLine(fit.Parameter(2)); }
public void FitDataToLineTest() { Interval r = Interval.FromEndpoints(0.0, 10.0); Func <double, double> fv = delegate(double x) { return(2.0 * x - 1.0); }; Func <double, double> fu = delegate(double x) { return(1.0 + x); }; UncertainMeasurementSample data = CreateDataSet(r, fv, fu, 20); // sanity check the data set Assert.IsTrue(data.Count == 20); // fit to a line FitResult line = data.FitToLine(); Assert.IsTrue(line.Dimension == 2); Assert.IsTrue(line.Parameter(0).ConfidenceInterval(0.95).ClosedContains(-1.0)); Assert.IsTrue(line.Parameter(1).ConfidenceInterval(0.95).ClosedContains(2.0)); Assert.IsTrue(line.GoodnessOfFit.LeftProbability < 0.95); // correlation coefficient should be related to covariance as expected Assert.IsTrue(TestUtilities.IsNearlyEqual(line.CorrelationCoefficient(0, 1), line.Covariance(0, 1) / line.Parameter(0).Uncertainty / line.Parameter(1).Uncertainty)); // fit to a 1st order polynomial and make sure it agrees FitResult poly = data.FitToPolynomial(1); Assert.IsTrue(poly.Dimension == 2); Assert.IsTrue(TestUtilities.IsNearlyEqual(poly.Parameters, line.Parameters)); Assert.IsTrue(TestUtilities.IsNearlyEqual(poly.CovarianceMatrix, line.CovarianceMatrix)); Assert.IsTrue(TestUtilities.IsNearlyEqual(poly.GoodnessOfFit.Statistic, line.GoodnessOfFit.Statistic)); Assert.IsTrue(TestUtilities.IsNearlyEqual(poly.GoodnessOfFit.LeftProbability, line.GoodnessOfFit.LeftProbability)); Assert.IsTrue(TestUtilities.IsNearlyEqual(poly.GoodnessOfFit.RightProbability, line.GoodnessOfFit.RightProbability)); // fit to a constant; the result should be poor FitResult constant = data.FitToConstant(); Assert.IsTrue(constant.GoodnessOfFit.LeftProbability > 0.95); }
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 FitResult pFit = set.FitToPolynomial(3); // fit it to a cubic polynomaial 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); }; FitResult fFit = set.FitToFunction(ff, new double[] { 0, 0, 0, 0 }); // the fits should agree Console.WriteLine("{0} ?= {1}", pFit.GoodnessOfFit.Statistic, fFit.GoodnessOfFit.Statistic); for (int i = 0; i < pFit.Dimension; i++) { Console.WriteLine("{0} ?= {1}", pFit.Parameter(i), fFit.Parameter(i)); Assert.IsTrue(pFit.Parameter(i).ConfidenceInterval(0.01).ClosedContains(fFit.Parameter(i).Value)); } // dimension Assert.IsTrue(pFit.Dimension == fFit.Dimension); // 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, fFit.Parameters, Math.Pow(TestUtilities.TargetPrecision, 0.3))); // covariance Assert.IsTrue(TestUtilities.IsNearlyEqual(pFit.CovarianceMatrix, fFit.CovarianceMatrix, Math.Pow(TestUtilities.TargetPrecision, 0.3))); }
public void FitDataToPolynomialTest() { Interval r = Interval.FromEndpoints(-10.0, 10.0); Polynomial p = Polynomial.FromCoefficients(1.0, -2.0, 3.0, -4.0, 5.0, -6.0); Func <double, double> fu = delegate(double x) { return(1.0 + 0.5 * Math.Cos(x)); }; UncertainMeasurementSample set = CreateDataSet(r, p.Evaluate, fu, 50); Assert.IsTrue(set.Count == 50); // fit to an appropriate polynomial UncertainMeasurementFitResult poly = set.FitToPolynomial(5); // the coefficients should match for (int i = 0; i < poly.Parameters.Count; i++) { Assert.IsTrue(poly.Parameters[i].Estimate.ConfidenceInterval(0.95).ClosedContains(p.Coefficient(i))); } // the fit should be good Assert.IsTrue(poly.GoodnessOfFit.Probability > 0.05); // fit to a lower order polynomial UncertainMeasurementFitResult low = set.FitToPolynomial(4); // the fit should be bad Assert.IsTrue(low.GoodnessOfFit.Statistic > poly.GoodnessOfFit.Statistic); Assert.IsTrue(low.GoodnessOfFit.Probability < 0.05); // fit to a higher order polynomial UncertainMeasurementFitResult high = set.FitToPolynomial(6); // the higher order coefficients should be compatible with zero Assert.IsTrue(high.Parameters[6].Estimate.ConfidenceInterval(0.95).ClosedContains(0.0)); // the fit should be better, but not too much better Assert.IsTrue(high.GoodnessOfFit.Statistic < poly.GoodnessOfFit.Statistic); }
private UncertainMeasurementSample CreateDataSet(Interval r, Func <double, double> fv, Func <double, double> fu, int n, int seed) { UncertainMeasurementSample set = new UncertainMeasurementSample(); UniformDistribution xd = new UniformDistribution(r); Random rng = new Random(seed); for (int i = 0; i < n; i++) { double x = xd.InverseLeftProbability(rng.NextDouble()); double ym = fv(x); double ys = fu(x); NormalDistribution yd = new NormalDistribution(ym, ys); double y = yd.InverseLeftProbability(rng.NextDouble()); //Console.WriteLine("{0}, {1}", x, new UncertainValue(y, ys)); UncertainMeasurement <double> point = new UncertainMeasurement <double>(x, y, ys); set.Add(point); } return(set); }
public void Bug6162() { // When UncertianMeasurementSample.FitToPolynomial used Cholesky inversion of (A^T A), this inversion // would fail when roundoff errors would made the matrix non-positive-definite. We have now changed // to QR decomposition, which is more robust. //real data double[] X_axis = new double[] { 40270.65625, 40270.6569444444, 40270.6576388888, 40270.6583333332, 40270.6590277776, 40270.659722222, 40270.6604166669, 40270.6611111113, 40270.6618055557, 40270.6625000001 }; double[] Y_axis = new double[] { 246.824996948242, 246.850006103516, 245.875, 246.225006103516, 246.975006103516, 247.024993896484, 246.949996948242, 246.875, 247.5, 247.100006103516 }; UncertainMeasurementSample DataSet = new UncertainMeasurementSample(); for (int i = 0; i < 10; i++) DataSet.Add(X_axis[i], Y_axis[i], 1); //for (int i = 0; i < 10; i++) DataSet.Add(X_axis[i] - 40270.0, Y_axis[i] - 247.0, 1); FitResult DataFit = DataSet.FitToPolynomial(3); for (int i = 0; i < DataFit.Dimension; i++) Console.WriteLine("a" + i.ToString() + " = " + DataFit.Parameter(i).Value); BivariateSample bs = new BivariateSample(); for (int i = 0; i < 10; i++) bs.Add(X_axis[i], Y_axis[i]); FitResult bsFit = bs.PolynomialRegression(3); for (int i = 0; i < bsFit.Dimension; i++) Console.WriteLine(bsFit.Parameter(i)); }
public void FitDataToPolynomialUncertaintiesTest() { // make sure the reported uncertainties it fit parameters really represent their standard deviation, // and that the reported off-diagonal elements really represent their correlations double[] xs = TestUtilities.GenerateUniformRealValues(-1.0, 2.0, 10); Func <double, double> fv = delegate(double x) { return(0.0 + 1.0 * x + 2.0 * x * x); }; Func <double, double> fu = delegate(double x) { return(0.5); }; // keep track of best-fit parameters and claimed parameter covariances MultivariateSample sample = new MultivariateSample(3); // generate 50 small data sets and fit each FitResult[] fits = new FitResult[50]; for (int i = 0; i < fits.Length; i++) { //DataSet set = CreateDataSet(Interval.FromEndpoints(-1.0,2.0), fv, fu, 10, i); UncertainMeasurementSample set = CreateDataSet(xs, fv, fu, 314159 + i); /* * foreach (DataPoint point in set) { * Console.WriteLine(" i={0} x={1} y={2}", i, point.X, point.Y); * } */ fits[i] = set.FitToPolynomial(2); /* * for (int j = 0; j < fits[i].Dimension; j++) { * Console.WriteLine("p[{0}] = {1}", j, fits[i].Parameter(j)); * } */ for (int j = 0; j < fits[i].Dimension; j++) { sample.Add(fits[i].Parameters); } } // check that parameters agree for (int i = 0; i < 3; i++) { Console.WriteLine(sample.Column(i).PopulationMean); } //Assert.IsTrue(sample.PopulationMean(0).ConfidenceInterval(0.95).ClosedContains(0.0)); //Assert.IsTrue(sample.PopulationMean(1).ConfidenceInterval(0.95).ClosedContains(1.0)); //Assert.IsTrue(sample.PopulationMean(2).ConfidenceInterval(0.95).ClosedContains(2.0)); /* * // check that the claimed covariances agree with the measured covariances * for (int i = 0; i < 3; i++) { * for (int j = 0; j < 3; j++) { * * Console.WriteLine("{0},{1} {2} {3}", i, j, sample.PopulationCovariance(i, j), C[i, j]); * * Assert.IsTrue(sample.PopulationCovariance(i, j).ConfidenceInterval(0.95).ClosedContains(C[i, j])); * } * } */ // for each parameter, verify that the standard devition of the reported values agrees with the (average) reported uncertainty double[] pMeans = new double[3]; for (int i = 0; i <= 2; i++) { Console.WriteLine("paramater {0}", i); Sample values = new Sample(); Sample uncertainties = new Sample(); for (int j = 0; j < fits.Length; j++) { UncertainValue p = fits[j].Parameter(i); values.Add(p.Value); uncertainties.Add(p.Uncertainty); } pMeans[i] = values.Mean; Console.WriteLine("reported values mean={0}, standard deviation={1}", values.Mean, values.StandardDeviation); Console.WriteLine("reported uncertainties mean={0}", uncertainties.Mean); Assert.IsTrue(values.PopulationStandardDeviation.ConfidenceInterval(0.95).ClosedContains(uncertainties.Mean)); } // for each parameter pair, verify that the covariances of the reported values agrees with the (average) reported covarance /* * for (int i = 0; i <= 2; i++) { * for (int j = 0; j <= 2; j++) { * // compute cov(i,j) * double cov = 0.0; * for (int k = 0; k < fits.Length; k++) { * cov += (fits[k].Parameter(i).Value - pMeans[i]) * (fits[k].Parameter(j).Value - pMeans[j]); * } * cov = cov / fits.Length; * // collect the reported covarainces * Sample covs = new Sample(); * for (int k = 0; k < fits.Length; k++) { * covs.Add(fits[k].Covariance(i, j)); * } * Console.WriteLine("cov({0},{1}) computed={2} reported={3}", i, j, cov, covs.PopulationMean); * // the computed covariance should agree with the (average) reported covariance * // problem: we need to estimate the uncertainty in our covariance, but that isn't ever computed * // note: covs just depend on x's, so the reported cov is the same for all fits * // solution: for now, just assume it scales with 1/Sqrt(N); long term, do a multivariate fit * //Assert.IsTrue((new UncertainValue(cov, Math.Abs(cov)* Math.Sqrt(2.0/fits.Length))).ConfidenceInterval(0.95).ClosedContains(covs.Mean)); * } * } */ }