protected override void Context()
{
base.Context();
_runResult1 = A.Fake <ResidualsResult>();
_runResult2 = A.Fake <ResidualsResult>();
_runResult3 = A.Fake <ResidualsResult>();
A.CallTo(() => _runResult1.TotalError).Returns(10);
A.CallTo(() => _runResult2.TotalError).Returns(5);
A.CallTo(() => _runResult3.TotalError).Returns(20);
_runResults = new[] { _runResult1, _runResult2, _runResult3 };
A.CallTo(_algorithm).WithReturnType <OptimizationRunProperties>()
.Invokes(x => { _objectiveFunction = x.GetArgument <Func <IReadOnlyList <OptimizedParameterValue>, OptimizationRunResult> >(1); })
.Returns(A.Fake <OptimizationRunProperties>());
A.CallTo(_residualCalculator).WithReturnType <ResidualsResult>()
.ReturnsLazily(x => _runResults[_counter++]);
sut.Run(_cancellationToken);
sut.RunStatusChanged += (o, e) =>
{
_raiseCount++;
_lastArgs = e;
};
}
public ResidualsResult Calculate(IReadOnlyList <SimulationRunResults> simulationsResults, IReadOnlyList <OutputMapping> allOutputMappings)
{
if (simulationsResults.Any(x => !x.Success))
{
return(residualResultWithErrorFrom(simulationsResults));
}
var simulationColumnsCache = new Cache <string, DataColumn>(x => x.PathAsString, x => null);
simulationsResults.Select(x => x.Results).Each(repo => simulationColumnsCache.AddRange(repo.AllButBaseGrid()));
var residualResult = new ResidualsResult();
foreach (var outputMapping in allOutputMappings)
{
var simulationColumn = simulationColumnsCache[outputMapping.FullOutputPath];
if (simulationColumn == null)
{
residualResult.ExceptionOccured = true;
residualResult.ExceptionMessage = Error.CannotFindSimulationResultsForOutput(outputMapping.FullOutputPath);
return(residualResult);
}
var outputResiduals = calculateOutputResiduals(simulationColumn, outputMapping);
residualResult.AddOutputResiduals(outputMapping.FullOutputPath, outputMapping.WeightedObservedData, outputResiduals);
}
return(residualResult);
}
public override void GlobalContext()
{
base.GlobalContext();
_optimizedParameterValue1 = new OptimizedParameterValue("P1", 10, 11, 5, 100, Scalings.Log);
_optimizedParameterValue2 = new OptimizedParameterValue("P2", 20, 211, 5, 100, Scalings.Linear);
_parameterIdentificationRunResult = new ParameterIdentificationRunResult();
_residualResults = new ResidualsResult();
_bestRunResult = new OptimizationRunResult {
ResidualsResult = _residualResults
};
_parameterIdentificationRunResult.BestResult = _bestRunResult;
_parameterIdentificationRunResult.Duration = new TimeSpan(1, 2, 3, 4);
_observedData1 = DomainHelperForSpecs.ObservedData("OBS1");
_observedData2 = DomainHelperForSpecs.ObservedData("OBS2");
_residualResults.AddOutputResiduals("OutputPath1", _observedData1, new[] { new Residual(1f, 2f, 1), new Residual(2f, 3f, 2) });
_residualResults.AddOutputResiduals("OutputPath2", _observedData2, new[] { new Residual(3f, 4f, 4) });
_bestRunResult.AddValue(_optimizedParameterValue1);
_bestRunResult.AddValue(_optimizedParameterValue2);
_bestRunResult.AddResult(DomainHelperForSpecs.IndividualSimulationDataRepositoryFor("S1"));
_bestRunResult.AddResult(DomainHelperForSpecs.IndividualSimulationDataRepositoryFor("S2"));
var workspace = IoC.Resolve <ICoreWorkspace>();
var project = IoC.Resolve <PKSimProject>();
workspace.Project = project;
project.AddObservedData(_observedData1);
project.AddObservedData(_observedData2);
_deserializedParameterIdentificationRunResult = SerializeAndDeserialize(_parameterIdentificationRunResult);
}
protected override OptimizationRunResult ObjectiveFunction(IReadOnlyList <OptimizedParameterValue> values)
{
var residualResult = new ResidualsResult()
{
ExceptionOccured = true,
ExceptionMessage = _objectiveFunctionErrorMessage
};
var optimizationRunResult = new OptimizationRunResult
{
ResidualsResult = residualResult
};
return(optimizationRunResult);
}
protected override void Context()
{
sut = new ConfidenceIntervalCalculator(new MatrixCalculator());
_residualsResult = new ResidualsResult();
_jacobianMatrix = new JacobianMatrix(new[] { "P1", "P2" });
_jacobianMatrix.AddRow(new JacobianRow("O1", 1, new[] { 1d, 5d }));
_jacobianMatrix.AddRow(new JacobianRow("O1", 2, new[] { 2d, 11d }));
_jacobianMatrix.AddRow(new JacobianRow("O1", 3, new[] { 3d, 12d }));
_jacobianMatrix.AddRow(new JacobianRow("O1", 4, new[] { 4d, 2d }));
_residualsResult.AddOutputResiduals(
"01",
new DataRepository("OBS"),
new[] { new Residual(1, 0.1000, 1), new Residual(2, -0.200, 1), new Residual(3, 1.0000, 1), new Residual(4, 0.5000, 1) }
);
}
protected override void Context()
{
base.Context();
_outputResidual1 = new OutputResiduals("O1", _observedData, new[] { new Residual(1f, 5f, 1), new Residual(2f, 10f, 1) });
_outputResidual2 = new OutputResiduals("O2", _observedData, new[] { new Residual(3f, 15f, 1), new Residual(4f, 19f, 1), new Residual(4f, 20f, 1) });
_residualResults = new ResidualsResult();
_optimizationRunResult = new OptimizationRunResult {
ResidualsResult = _residualResults
};
_residualResults.AddOutputResiduals(_outputResidual1);
_residualResults.AddOutputResiduals(_outputResidual2);
_binInterval1 = new BinInterval(0, 17);
_binInterval2 = new BinInterval(18, 25);
A.CallTo(_binIntervalCreator).WithReturnType <IReadOnlyList <BinInterval> >().Returns(new[] { _binInterval1, _binInterval2 });
}
protected override void Context()
{
_view = A.Fake <IParameterIdentificationSingleRunAnalysisView>();
_chartEditorAndDisplayPresenter = A.Fake <IChartEditorAndDisplayPresenter>();
_curveNamer = A.Fake <ICurveNamer>();
_dataColumnToPathElementsMapper = A.Fake <IDataColumnToPathElementsMapper>();
_chartTemplatingTask = A.Fake <IChartTemplatingTask>();
_presentationSettingsTask = A.Fake <IPresentationSettingsTask>();
_dimensionFactory = A.Fake <IDimensionFactory>();
_predictedVsObservedService = A.Fake <IPredictedVsObservedChartService>();
_chartEditorLayoutTask = A.Fake <IChartEditorLayoutTask>();
_projectRetreiver = A.Fake <IProjectRetriever>();
_chartPresenterContext = A.Fake <ChartPresenterContext>();
A.CallTo(() => _chartPresenterContext.EditorAndDisplayPresenter).Returns(_chartEditorAndDisplayPresenter);
A.CallTo(() => _chartPresenterContext.CurveNamer).Returns(_curveNamer);
A.CallTo(() => _chartPresenterContext.DataColumnToPathElementsMapper).Returns(_dataColumnToPathElementsMapper);
A.CallTo(() => _chartPresenterContext.TemplatingTask).Returns(_chartTemplatingTask);
A.CallTo(() => _chartPresenterContext.PresenterSettingsTask).Returns(_presentationSettingsTask);
A.CallTo(() => _chartPresenterContext.DimensionFactory).Returns(_dimensionFactory);
A.CallTo(() => _chartPresenterContext.EditorLayoutTask).Returns(_chartEditorLayoutTask);
A.CallTo(() => _chartPresenterContext.ProjectRetriever).Returns(_projectRetreiver);
_observationData = DomainHelperForSpecs.ObservedData();
_simulationData = DomainHelperForSpecs.IndividualSimulationDataRepositoryFor("Simulation");
_noDimensionColumnForSimulation = _simulationData.FirstDataColumn();
_predictedVsObservedChart = new ParameterIdentificationPredictedVsObservedChart().WithAxes();
_parameterIdentification = A.Fake <ParameterIdentification>();
sut = new ParameterIdentificationPredictedVsObservedChartPresenter(_view, _chartPresenterContext, _predictedVsObservedService);
_parameterIdentificationRunResult = A.Fake <ParameterIdentificationRunResult>();
A.CallTo(() => _parameterIdentification.Results).Returns(new[] { _parameterIdentificationRunResult });
_residualResults = new ResidualsResult();
_optimizationRunResult = new OptimizationRunResult {
ResidualsResult = _residualResults, SimulationResults = new List <DataRepository> {
_simulationData
}
};
_parameterIdentificationRunResult.BestResult = _optimizationRunResult;
sut.InitializeAnalysis(_predictedVsObservedChart);
}
protected override void Context()
{
_presentationSettingsTask = A.Fake <IPresentationSettingsTask>();
_view = A.Fake <IParameterIdentificationSingleRunAnalysisView>();
_chartEditorAndDisplayPresenter = A.Fake <IChartEditorAndDisplayPresenter>();
_curveNamer = A.Fake <ICurveNamer>();
_pathElementsMapper = A.Fake <IDataColumnToPathElementsMapper>();
_chartTemplatingTask = A.Fake <IChartTemplatingTask>();
_dimensionFactory = A.Fake <IDimensionFactory>();
_chartEditorLayoutTask = A.Fake <IChartEditorLayoutTask>();
_projectRetreiver = A.Fake <IProjectRetriever>();
_chartPresenterContext = A.Fake <ChartPresenterContext>();
A.CallTo(() => _chartPresenterContext.EditorAndDisplayPresenter).Returns(_chartEditorAndDisplayPresenter);
A.CallTo(() => _chartPresenterContext.CurveNamer).Returns(_curveNamer);
A.CallTo(() => _chartPresenterContext.DataColumnToPathElementsMapper).Returns(_pathElementsMapper);
A.CallTo(() => _chartPresenterContext.TemplatingTask).Returns(_chartTemplatingTask);
A.CallTo(() => _chartPresenterContext.PresenterSettingsTask).Returns(_presentationSettingsTask);
A.CallTo(() => _chartPresenterContext.DimensionFactory).Returns(_dimensionFactory);
A.CallTo(() => _chartPresenterContext.EditorLayoutTask).Returns(_chartEditorLayoutTask);
A.CallTo(() => _chartPresenterContext.ProjectRetriever).Returns(_projectRetreiver);
sut = new ParameterIdentificationResidualVsTimeChartPresenter(_view, _chartPresenterContext);
_residualVsTimeChart = new ParameterIdentificationResidualVsTimeChart().WithAxes();
_parameterIdentification = A.Fake <ParameterIdentification>();
_parameterIdentificationRunResult = A.Fake <ParameterIdentificationRunResult>();
A.CallTo(() => _parameterIdentification.Results).Returns(new[] { _parameterIdentificationRunResult });
_residualResults = new ResidualsResult();
_optimizationRunResult = new OptimizationRunResult {
ResidualsResult = _residualResults
};
_parameterIdentificationRunResult.BestResult = _optimizationRunResult;
A.CallTo(() => _parameterIdentification.MinObservedDataTime).Returns(10);
A.CallTo(() => _parameterIdentification.MaxObservedDataTime).Returns(50);
}
public Matrix CorrelationMatrixFrom(JacobianMatrix jacobianMatrix, ResidualsResult residualsResult)
{
try
{
//Norm = (1./ sqrt(diag(dpdpMat))) * (1./ sqrt(diag(dpdpMat)))'
//corr_matrix = dpdpMat.* Norm
var dpdpMat = calculateCovarianceMatrix(jacobianMatrix, residualsResult);
dpdpMat.Diagonal();
var std = dpdpMat.Diagonal();
std.PointwisePower(-0.5, std);
var norm1 = Matrix <double> .Build.DenseOfColumnVectors(std);
var norm = norm1.Multiply(norm1.Transpose());
var correlationMatrix = dpdpMat.PointwiseMultiply(norm);
return(matrixFrom(jacobianMatrix.ParameterNames, correlationMatrix));
}
catch (Exception e)
{
throw new MatrixCalculationException(Error.CorrelationMatrixCannotBeCalculated, e);
}
}
protected override void Context()
{
base.Context();
_simulation = A.Fake <ISimulation>();
_project = A.Fake <IProject>();
_parameterIdentification = new ParameterIdentification();
A.CallTo(() => _executionContext.Project).Returns(_project);
A.CallTo(() => _project.AllParameterIdentifications).Returns(new[] { _parameterIdentification });
_parameterIdentification.AddSimulation(_simulation);
_initialObjectPath = new ObjectPath("oldName", "path");
var parameterIdentificationRunResult = new ParameterIdentificationRunResult {
BestResult = new OptimizationRunResult()
};
_simulationDataRepository = DomainHelperForSpecs.SimulationDataRepositoryFor("oldName");
_observationDataRepository = DomainHelperForSpecs.ObservedData();
_observationDataRepository.AllButBaseGrid().Each(x => x.QuantityInfo.Path = _initialObjectPath);
_simulationDataRepository.AllButBaseGrid().Each(x => x.QuantityInfo.Path = _initialObjectPath);
parameterIdentificationRunResult.BestResult.AddResult(_simulationDataRepository);
_residualsResult = new ResidualsResult();
_residualsResult.AddOutputResiduals(_initialObjectPath.PathAsString, _observationDataRepository, new List <Residual> {
new Residual(0, 1, 1)
});
parameterIdentificationRunResult.BestResult.ResidualsResult = _residualsResult;
_parameterIdentification.AddResult(parameterIdentificationRunResult);
var outputMapping = new OutputMapping
{
WeightedObservedData = new WeightedObservedData(_observationDataRepository),
OutputSelection = new ParameterSelection(_simulation, _initialObjectPath.PathAsString)
};
_parameterIdentification.AddOutputMapping(outputMapping);
}
/// <summary>
/// Optimize objective function (x[0]-3)^2+(x[1]-4)^2
/// </summary>
/// <param name="values"></param>
/// <returns></returns>
protected virtual OptimizationRunResult ObjectiveFunction(IReadOnlyList <OptimizedParameterValue> values)
{
var residualResult = new ResidualsResult();
var outputResiduals = new OutputResiduals("A|B", new DataRepository(), new[]
{
new Residual(0, values[0].Value - 3, 1),
new Residual(0, values[1].Value - 4, 1)
});
residualResult.AddOutputResiduals(outputResiduals);
var optimizationRunResult = new OptimizationRunResult
{
ResidualsResult = residualResult,
Values = values,
};
if (optimizationRunResult.TotalError < _optimizationResult.TotalError)
{
_optimizationResult = optimizationRunResult;
}
return(optimizationRunResult);
}
protected override void Context()
{
_matrixCalculator = A.Fake <IMatrixCalculator>();
_dataRepositoryCreator = A.Fake <IConfidenceIntervalDataRepositoryCreator>();
sut = new TimeProfileConfidenceIntervalCalculator(_matrixCalculator, _dataRepositoryCreator);
_identificationParameter1 = new IdentificationParameter().WithName("IP1");
_identificationParameter2 = new IdentificationParameter().WithName("IP2");
var parameterNames = new[] { _identificationParameter1.Name, _identificationParameter2.Name };
_parameterIdentification = A.Fake <ParameterIdentification>();
_runResult = A.Fake <ParameterIdentificationRunResult>();
_runResult.JacobianMatrix = new JacobianMatrix(parameterNames);
_allOutputMappings = new List <OutputMapping>();
_allVariableIdentificationParameters = new List <IdentificationParameter>();
_residualResults = new ResidualsResult();
_runResult.BestResult.ResidualsResult = _residualResults;
A.CallTo(() => _parameterIdentification.AllOutputMappings).Returns(_allOutputMappings);
A.CallTo(() => _parameterIdentification.AllVariableIdentificationParameters).Returns(_allVariableIdentificationParameters);
_simulation1 = A.Fake <ISimulation>().WithName("S1");
_simulation2 = A.Fake <ISimulation>().WithName("S2");
_output1 = createOutput(_simulation1, "C1", Scalings.Log);
_allOutputMappings.Add(_output1);
_output2 = createOutput(_simulation2, "C2", Scalings.Linear);
_allOutputMappings.Add(_output2);
_output3 = createOutput(_simulation1, "C3", Scalings.Log);
_allOutputMappings.Add(_output3);
_output4 = createOutput(_simulation2, "C4", Scalings.Linear);
_allOutputMappings.Add(_output4);
_ps1_1 = createParameterSelection(_simulation1, "P1_1");
_identificationParameter1.AddLinkedParameter(_ps1_1);
_ps2_1 = createParameterSelection(_simulation1, "P2_1");
A.CallTo(() => _ps2_1.Dimension).Returns(_ps1_1.Dimension);
_identificationParameter1.AddLinkedParameter(_ps2_1);
_ps1_2 = createParameterSelection(_simulation1, "P1_2");
_identificationParameter2.AddLinkedParameter(_ps1_2);
_ps2_2 = createParameterSelection(_simulation2, "P2_2");
A.CallTo(() => _ps2_2.Dimension).Returns(_ps1_2.Dimension);
_identificationParameter2.AddLinkedParameter(_ps2_2);
_allVariableIdentificationParameters.Add(_identificationParameter1);
_allVariableIdentificationParameters.Add(_identificationParameter2);
_observedData1 = A.Fake <DataRepository>();
_observedData2 = A.Fake <DataRepository>();
_observedData3 = A.Fake <DataRepository>();
_observedData4 = A.Fake <DataRepository>();
_observedData5 = A.Fake <DataRepository>();
_residualResults.AddOutputResiduals(_output1.FullOutputPath, _observedData1, new[]
{
new Residual(2, 0.10, 1),
new Residual(4, 0.40, 2),
new Residual(6, 1.00, 1),
new Residual(8, 0, 0),
});
_residualResults.AddOutputResiduals(_output1.FullOutputPath, _observedData2, new[]
{
new Residual(6, 0.20, 2),
new Residual(8, 0.80, 4),
new Residual(10, -0.20, 2),
new Residual(12, 0, 0),
});
_residualResults.AddOutputResiduals(_output2.FullOutputPath, _observedData3, new[]
{
new Residual(2, 0, 0),
new Residual(4, 0.20, 2),
new Residual(6, -0.20, 2),
new Residual(8, 0, 0),
});
_residualResults.AddOutputResiduals(_output2.FullOutputPath, _observedData4, new[]
{
new Residual(6, 0.20, 2),
new Residual(8, 0.80, 4),
new Residual(10, -0.20, 2),
new Residual(12, 0, 0),
});
_residualResults.AddOutputResiduals(_output2.FullOutputPath, _observedData5, new[]
{
new Residual(6, 0, 0),
new Residual(8, 0, 0),
new Residual(10, 0, 0),
new Residual(12, 0, 0),
});
var baseGrid = new BaseGrid("Time", DomainHelperForSpecs.TimeDimensionForSpecs())
{
Values = new[] { 0f, 2f, 4f, 6f, 8f, 10f, 12f, 14f, 16f }
};
var C1 = new DataColumn
{
BaseGrid = baseGrid,
Values = new[] { 0f, 0.71f, 2.10f, 3.14f, 3.76f, 4.04f, 4.12f, 4.09f, 4.02f }
};
A.CallTo(() => _runResult.BestResult.SimulationResultFor(_output1.FullOutputPath)).Returns(C1);
var C2 = new DataColumn
{
BaseGrid = baseGrid,
Values = new[] { 0f, 0.37f, 0.38f, 0.31f, 0.23f, 0.17f, 0.14f, 0.12f, 0.11f }
};
A.CallTo(() => _runResult.BestResult.SimulationResultFor(_output2.FullOutputPath)).Returns(C2);
var C3 = new DataColumn
{
BaseGrid = baseGrid,
Values = new[] { 0f, 0.53f, 0.54f, 0.43f, 0.32f, 0.25f, 0.20f, 0.17f, 0.16f }
};
A.CallTo(() => _runResult.BestResult.SimulationResultFor(_output3.FullOutputPath)).Returns(C3);
var C4 = new DataColumn
{
BaseGrid = baseGrid,
Values = new[] { 0f, 0.16f, 0.16f, 0.13f, 0.10f, 0.07f, 0.06f, 0.05f, 0.05f }
};
A.CallTo(() => _runResult.BestResult.SimulationResultFor(_output4.FullOutputPath)).Returns(C4);
var covarianceMatrix = new Matrix(parameterNames, parameterNames);
A.CallTo(() => _matrixCalculator.CovarianceMatrixFrom(_runResult.JacobianMatrix, _residualResults)).Returns(covarianceMatrix);
covarianceMatrix.SetRow(0, new[] { 5.05, -1.22 });
covarianceMatrix.SetRow(1, new[] { -1.22, 0.51 });
_runResult.JacobianMatrix.AddPartialDerivatives(createPartialDerivatives(_output1.FullOutputPath, parameterNames, new[]
{
new[] { 0d, 0d },
new[] { 1d, 2d },
new[] { 2d, 3d },
new[] { 1d, 1d },
new[] { 0.5d, 0.7d },
new[] { 0.4d, 0.5d },
new[] { 0.3d, 0.5d },
new[] { 0.3d, 0.2d },
new[] { 0.1d, 0.2d }
}));
_runResult.JacobianMatrix.AddPartialDerivatives(createPartialDerivatives(_output2.FullOutputPath, parameterNames, new[]
{
new[] { 0d, 0d },
new[] { -1d, -2d },
new[] { -1d, -2d },
new[] { -0.5d, -1d },
new[] { 0.1d, 0.1d },
new[] { -0.1d, -0.1d },
new[] { 0.2d, 0.2d },
new[] { 0.3d, 0.3d },
new[] { 0.2d, 0.2d }
}));
_runResult.JacobianMatrix.AddPartialDerivatives(createPartialDerivatives(_output3.FullOutputPath, parameterNames, new[]
{
new[] { 0d, 0d },
new[] { 1d, 2d },
new[] { 2d, 3d },
new[] { 1d, 1d },
new[] { 0.5d, 0.7d },
new[] { 0.4d, 0.5d },
new[] { 0.3d, 0.5d },
new[] { 0.3d, 0.2d },
new[] { 0.1d, 0.2d },
}));
_runResult.JacobianMatrix.AddPartialDerivatives(createPartialDerivatives(_output4.FullOutputPath, parameterNames, new[]
{
new[] { 0d, 0d },
new[] { -4d, -4d },
new[] { -3d, -3d },
new[] { -2d, -2d },
new[] { -1d, -1d },
new[] { -0.5d, -0.5d },
new[] { -0.4d, -0.4d },
new[] { -0.3d, -0.3d },
new[] { -0.2d, -0.2d },
}));
_confidenceIntervals = new Cache <string, double[]>();
A.CallTo(() => _dataRepositoryCreator.CreateFor(A <string> ._, A <double[]> ._, A <OutputMapping> ._, A <OptimizationRunResult> ._))
.Invokes(x => { _confidenceIntervals.Add(x.GetArgument <OutputMapping>(2).FullOutputPath, x.GetArgument <double[]>(1)); })
.Returns(new DataRepository());
}
private Matrix <double> calculateCovarianceMatrix(JacobianMatrix jacobianMatrix, ResidualsResult residualsResult)
{
try
{
var resut = calculateFisherMatrix(jacobianMatrix);
var fisher = resut.Fisher;
var jacobian = resut.Jacobian;
var jacobiTransposed = resut.JacobiTransposed;
var fisherInv = fisher.PseudoInverse();
var numberOfIdentifiedParameters = jacobianMatrix.ColumnCount;
var numberOfResiduls = jacobianMatrix.RowCount;
// covariance matrix = fisher_inv* Jacob'*eye(length(resid))*sum(resid.^2)/(size(Jacob,1)-size(Jacob,2))*Jacob*fisher_inv;
var identity = Matrix <double> .Build.DenseIdentity(numberOfResiduls);
identity = identity.Multiply(residualsResult.SumResidual2 / (numberOfResiduls - numberOfIdentifiedParameters));
return(fisherInv.Multiply(jacobiTransposed).Multiply(identity).Multiply(jacobian).Multiply(fisherInv));
}
catch (Exception e)
{
throw new MatrixCalculationException(Error.CovarianceMatrixCannotBeCalculated, e);
}
}
public Matrix CovarianceMatrixFrom(JacobianMatrix jacobianMatrix, ResidualsResult residualsResult)
{
var dpdpMat = calculateCovarianceMatrix(jacobianMatrix, residualsResult);
return(matrixFrom(jacobianMatrix.ParameterNames, dpdpMat));
}
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);
}
protected override void Because()
{
_residualResult = sut.Calculate(_simulationRunResultsList, _outputMappings);
_outputResiduals = _residualResult.AllOutputResidualsFor(_fullOutputPath).First();
}
protected override void Because()
{
_residualResult = sut.Calculate(_simulationRunResultsList, _outputMappings);
}
