public void ValidateInverseCumulativeDistribution(double location, double scale, double dof, double x, double p)
{
var dist = new StudentT(location, scale, dof);
Assert.That(dist.InverseCumulativeDistribution(p), Is.EqualTo(x).Within(1e-6));
Assert.That(StudentT.InvCDF(location, scale, dof, p), Is.EqualTo(x).Within(1e-6));
}
private void CalculaICTStudent(double media, double variancia, int n, ref IntervaloConfianca ic)
{
StudentT ts = new StudentT(0, 1, n - 1);
var percentil = ts.InverseCumulativeDistribution(0.975);
ic.U = media + percentil * Math.Sqrt(variancia / n);
ic.L = media - percentil * Math.Sqrt(variancia / n);
}
public double GetMeanErrorAt(double confidence)
{
if (GetN() <= 2)
{
return(Double.NaN);
}
var distribution = new StudentT(0, 1, GetN() - 1);
double a = distribution.InverseCumulativeDistribution(1 - (1 - confidence) / 2);
return(a * GetStandardDeviation() / Math.Sqrt(GetN()));
}
private IReadOnlyList <DataRepository> calculateConfidenceIntervalFor(ParameterIdentification parameterIdentification, ParameterIdentificationRunResult runResult, string confidenceIntervalName, Func <Scalings, double, double, double, double> intervalCalculation, bool requiresActiveOutput)
{
var dataRepositories = new List <DataRepository>();
if (runResult.JacobianMatrix == null)
{
return(dataRepositories);
}
var residualsResult = runResult.BestResult.ResidualsResult;
var allResiduals = residualsResult.AllResidualsWithWeightsStrictBiggerZero;
var nr = allResiduals.Count;
var np = parameterIdentification.AllVariableIdentificationParameters.Count();
var df = nr - np;
if (df <= 0)
{
return(dataRepositories);
}
var Q = residualsResult.SumResidual2;
try
{
_sigma = Math.Sqrt(Q / df);
_runResult = runResult;
var covariance = _matrixCalculator.CovarianceMatrixFrom(runResult.JacobianMatrix, residualsResult);
_covP = Matrix <double> .Build.DenseOfRowArrays(covariance.Rows);
var qt = new StudentT(0.0, 1, df);
_dt = qt.InverseCumulativeDistribution(1 - Constants.CONFIDENCE_INTERVAL_ALPHA / 2);
parameterIdentification.AllOutputMappings.GroupBy(x => x.FullOutputPath).Each(x =>
{
var outputMapping = x.ElementAt(0);
var dataRepository = _dataRepositoryCreator.CreateFor(confidenceIntervalName, confidanceIntervalFor(outputMapping, intervalCalculation, requiresActiveOutput), outputMapping, runResult.BestResult);
if (!dataRepository.IsNull())
{
dataRepositories.Add(dataRepository);
}
});
return(dataRepositories);
}
finally
{
_covP = null;
_sigma = double.NaN;
_dt = double.NaN;
_runResult = null;
}
}
public ICache <string, double> ConfidenceIntervalFrom(JacobianMatrix jacobianMatrix, ResidualsResult residualsResult)
{
var confidenceInterval = new Cache <string, double>(x => double.NaN);
Matrix covarianceMatrix;
try
{
covarianceMatrix = _matrixCalculator.CovarianceMatrixFrom(jacobianMatrix, residualsResult);
}
catch (MatrixCalculationException)
{
return(confidenceInterval);
}
if (covarianceMatrix == null)
{
return(confidenceInterval);
}
var numberOfParameters = jacobianMatrix.ColumnCount;
var numberOfData = jacobianMatrix.RowCount;
var df = numberOfData - numberOfParameters;
if (df <= 0)
{
return(confidenceInterval);
}
var t = new StudentT(0.0, 1, df);
var dt = t.InverseCumulativeDistribution(1 - Constants.CONFIDENCE_INTERVAL_ALPHA / 2);
jacobianMatrix.ParameterNames.Each((path, index) =>
{
var value = Math.Sqrt(covarianceMatrix[index][index]);
confidenceInterval.Add(path, dt * value);
});
return(confidenceInterval);
}
