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 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);
UncertainMeasurementFitResult fit = data.FitToLine();
sample.Add(fit.Parameters.ValuesVector);
covariance = fit.Parameters.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 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
UncertainMeasurementFitResult prop = set.FitToProportionality();
Assert.IsTrue(prop.Parameters.Count == 1);
Assert.IsTrue(prop.Parameters[0].Estimate.ConfidenceInterval(0.95).ClosedContains(0.5));
Assert.IsTrue(prop.GoodnessOfFit.Probability > 0.05);
// fit to line
UncertainMeasurementFitResult line = set.FitToLine();
Assert.IsTrue(line.Parameters.Count == 2);
// line's intercept should be compatible with zero and slope with proportionality constant
Assert.IsTrue(line.Parameters[0].Estimate.ConfidenceInterval(0.95).ClosedContains(0.0));
Assert.IsTrue(line.Parameters[1].Estimate.ConfidenceInterval(0.95).ClosedContains(prop.Parameters[0].Estimate.Value));
// the fit should be better, but not too much better
Assert.IsTrue(line.GoodnessOfFit.Statistic < prop.GoodnessOfFit.Statistic);
}
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)); } };
UncertainMeasurementFitResult result = set.FitToLinearFunction(fs);
// the fit should be right right dimension
Assert.IsTrue(result.Parameters.Count == 2);
// the coefficients should match
Assert.IsTrue(result.Parameters[0].Estimate.ConfidenceInterval(0.95).ClosedContains(2.0));
Assert.IsTrue(result.Parameters[1].Estimate.ConfidenceInterval(0.95).ClosedContains(1.0));
// diagonal covarainces should match errors
Assert.IsTrue(TestUtilities.IsNearlyEqual(Math.Sqrt(result.Parameters.CovarianceMatrix[0, 0]), result.Parameters[0].Estimate.Uncertainty));
Assert.IsTrue(TestUtilities.IsNearlyEqual(Math.Sqrt(result.Parameters.CovarianceMatrix[1, 1]), result.Parameters[1].Estimate.Uncertainty));
}
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 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);
UncertainMeasurementFitResult 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.Probability > 0.05);
}
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]);
};
UncertainMeasurementFitResult fit = set.FitToFunction(ff, new double[] { 1.3, 1.1, 0.1 });
}
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);
}
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
UncertainMeasurementFitResult line = data.FitToLine();
Assert.IsTrue(line.Parameters.Count == 2);
Assert.IsTrue(line.Parameters[0].Estimate.ConfidenceInterval(0.95).ClosedContains(-1.0));
Assert.IsTrue(line.Parameters[1].Estimate.ConfidenceInterval(0.95).ClosedContains(2.0));
Assert.IsTrue(line.GoodnessOfFit.Probability > 0.05);
// correlation coefficient should be related to covariance as expected
//Assert.IsTrue(TestUtilities.IsNearlyEqual(line.Parameters.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
UncertainMeasurementFitResult poly = data.FitToPolynomial(1);
Assert.IsTrue(poly.Parameters.Count == 2);
Assert.IsTrue(TestUtilities.IsNearlyEqual(poly.Parameters.ValuesVector, line.Parameters.ValuesVector));
Assert.IsTrue(TestUtilities.IsNearlyEqual(poly.Parameters.CovarianceMatrix, line.Parameters.CovarianceMatrix));
Assert.IsTrue(TestUtilities.IsNearlyEqual(poly.GoodnessOfFit.Statistic, line.GoodnessOfFit.Statistic));
Assert.IsTrue(TestUtilities.IsNearlyEqual(poly.GoodnessOfFit.Probability, line.GoodnessOfFit.Probability));
// fit to a constant; the result should be poor
UncertainMeasurementFitResult constant = data.FitToConstant();
Assert.IsTrue(constant.GoodnessOfFit.Probability < 0.05);
}
