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);
}
}
protected override void Context()
{
base.Context();
_jacobianMatrix = new JacobianMatrix(new[] { "P1", "P2" });
_jacobianMatrix.AddRow(new JacobianRow("O1", 1, new[] { 1d, 5d }));
_jacobianMatrix.AddRow(new JacobianRow("O1", 2, new[] { 2d, 11d }));
}
private FisherCalculationResults calculateFisherMatrix(JacobianMatrix jacobianMatrix)
{
//fisher = Jacob'*Jacob;
var jacobi = jacobiDenseMatrixFrom(jacobianMatrix);
var jacobiTransposed = jacobi.Transpose();
return(new FisherCalculationResults
{
Jacobian = jacobi,
JacobiTransposed = jacobiTransposed,
Fisher = jacobiTransposed.Multiply(jacobi)
});
}
protected override void Context()
{
base.Context();
_jacobianMatrix = new JacobianMatrix(new[] { "A" });
_parameterIdentification.Configuration.CalculateJacobian = true;
A.CallTo(_jacobianMatrixCalculator).WithReturnType <JacobianMatrix>().Returns(_jacobianMatrix);
A.CallTo(() => _algorithm.Optimize(A <OptimizedParameterConstraint[]> ._, A <Func <IReadOnlyList <OptimizedParameterValue>, OptimizationRunResult> > ._))
.Invokes(x =>
{
var objectiveFunction = x.GetArgument <Func <IReadOnlyList <OptimizedParameterValue>, OptimizationRunResult> >(1);
objectiveFunction(new[] { new OptimizedParameterValue("P1", 5d, 5d) });
});
}
public void TestSerialization()
{
var x1 = new JacobianMatrix(new[] { "P1", "P2" });
var partialDerivatives = new PartialDerivatives("O1", x1.ParameterNames);
partialDerivatives.AddPartialDerivative(new[] { 1d, 2d });
partialDerivatives.AddPartialDerivative(new[] { 3d, 4d });
x1.AddPartialDerivatives(partialDerivatives);
var x2 = SerializeAndDeserialize(x1);
AssertForSpecs.AreEqualJacobianMatrix(x1, x2);
}
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) }
);
}
public JacobianMatrix CalculateFor(ParameterIdentification parameterIdentification, OptimizationRunResult runResult, ICache <ISimulation, ISimModelBatch> simModelBatches)
{
var allVariableIdentificationParameters = parameterIdentification.AllVariableIdentificationParameters.ToList();
var matrix = new JacobianMatrix(allVariableIdentificationParameters.AllNames());
foreach (var outputMappings in parameterIdentification.AllOutputMappings.GroupBy(x => x.FullOutputPath))
{
var outputMapping = outputMappings.ElementAt(0);
var simModelBatch = simModelBatches[outputMapping.Simulation];
var fullOutputPath = outputMappings.Key;
var outputResult = runResult.SimulationResultFor(fullOutputPath);
matrix.AddRows(jacobianRowFrom(runResult, fullOutputPath, outputResult, allVariableIdentificationParameters, outputMapping, simModelBatch));
matrix.AddPartialDerivatives(partialDerivativesFrom(fullOutputPath, outputResult, allVariableIdentificationParameters, outputMapping, simModelBatch));
}
return(matrix);
}
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);
}
}
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);
}
private Matrix <double> jacobiDenseMatrixFrom(JacobianMatrix jacobianMatrix)
{
return(Matrix <double> .Build.DenseOfRowArrays(jacobianMatrix.Rows.Select(x => x.Values)));
}
public Matrix CovarianceMatrixFrom(JacobianMatrix jacobianMatrix, ResidualsResult residualsResult)
{
var dpdpMat = calculateCovarianceMatrix(jacobianMatrix, residualsResult);
return(matrixFrom(jacobianMatrix.ParameterNames, dpdpMat));
}
public Matrix FisherMatrixFrom(JacobianMatrix jacobianMatrix)
{
return(matrixFrom(jacobianMatrix.ParameterNames, calculateFisherMatrix(jacobianMatrix).Fisher));
}
protected override void Because()
{
_result = sut.CalculateFor(_parameterIdentification, _runResult, _simModelBatches);
}