/// <summary>
/// get the k^th order penalty matrix, P. This is defined as P = (D^T)*D , where D is the k^th order difference
/// matrix (see getDifferenceMatrix), so the scalar amount (x^T)*P*x = |Dx|^2 is greater the more k^th order
/// differences there are in the vector, x. This can then act as a penalty on x in some optimisation routine where
/// x is the vector of (fit) parameters. </summary>
/// <param name="m"> Length of the vector. </param>
/// <param name="k"> Difference order. Require m > k </param>
/// <returns> The k^th order penalty matrix, P </returns>
public static DoubleMatrix getPenaltyMatrix(int m, int k)
{
ArgChecker.notNegativeOrZero(m, "m");
ArgChecker.notNegative(k, "k");
ArgChecker.isTrue(k < m, "Difference order too high, require m > k, but have: m = {} and k = {}", m, k);
if (k == 0)
{
return(DoubleMatrix.identity(m));
}
DoubleMatrix d = getDifferenceMatrix(m, k);
DoubleMatrix dt = MA.getTranspose(d);
return((DoubleMatrix)MA.multiply(dt, d));
}
private DoubleMatrix getDiffMatrix(int m, int k)
{
ArgChecker.isTrue(k < m, "difference order too high");
//JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java:
//ORIGINAL LINE: double[][] data = new double[m][m];
double[][] data = RectangularArrays.ReturnRectangularDoubleArray(m, m);
if (m == 0)
{
return(DoubleMatrix.copyOf(data));
}
int[] coeff = new int[k + 1];
int sign = 1;
for (int i = k; i >= 0; i--)
{
coeff[i] = (int)(sign * binomialCoefficient(k, i));
sign *= -1;
}
for (int i = k; i < m; i++)
{
for (int j = 0; j < k + 1; j++)
{
data[i][j + i - k] = coeff[j];
}
}
DoubleMatrix d = DoubleMatrix.copyOf(data);
DoubleMatrix dt = _algebra.getTranspose(d);
return((DoubleMatrix)_algebra.multiply(dt, d));
}
internal override DoubleArray computedBucketedCs01(ResolvedCdsTrade trade, IList <ResolvedCdsTrade> bucketCds, CreditRatesProvider ratesProvider, ReferenceData refData)
{
checkCdsBucket(trade, bucketCds);
ResolvedCds product = trade.Product;
Currency currency = product.Currency;
StandardId legalEntityId = product.LegalEntityId;
LocalDate valuationDate = ratesProvider.ValuationDate;
int nBucket = bucketCds.Count;
DoubleArray impSp = impliedSpread(bucketCds, ratesProvider, refData);
NodalCurve creditCurveBase = Calibrator.calibrate(bucketCds, impSp, DoubleArray.filled(nBucket), CurveName.of("baseImpliedCreditCurve"), valuationDate, ratesProvider.discountFactors(currency), ratesProvider.recoveryRates(legalEntityId), refData);
IsdaCreditDiscountFactors df = IsdaCreditDiscountFactors.of(currency, valuationDate, creditCurveBase);
CreditRatesProvider ratesProviderBase = ratesProvider.toImmutableCreditRatesProvider().toBuilder().creditCurves(ImmutableMap.of(Pair.of(legalEntityId, currency), LegalEntitySurvivalProbabilities.of(legalEntityId, df))).build();
double[][] res = new double[nBucket][];
PointSensitivities pointPv = Pricer.presentValueOnSettleSensitivity(trade, ratesProviderBase, refData);
DoubleArray vLambda = ratesProviderBase.singleCreditCurveParameterSensitivity(pointPv, legalEntityId, currency).Sensitivity;
for (int i = 0; i < nBucket; i++)
{
PointSensitivities pointSp = Pricer.parSpreadSensitivity(bucketCds[i], ratesProviderBase, refData);
res[i] = ratesProviderBase.singleCreditCurveParameterSensitivity(pointSp, legalEntityId, currency).Sensitivity.toArray();
}
DoubleMatrix jacT = MATRIX_ALGEBRA.getTranspose(DoubleMatrix.ofUnsafe(res));
LUDecompositionResult luRes = DECOMPOSITION.apply(jacT);
DoubleArray vS = luRes.solve(vLambda);
return(vS);
}
/// <summary>
/// Constructor. </summary>
/// <param name="lArray"> The matrix L as an array of doubles. </param>
public CholeskyDecompositionOpenGammaResult(double[][] lArray)
{
_lArray = lArray;
_l = DoubleMatrix.copyOf(_lArray);
_lT = ALGEBRA.getTranspose(_l);
_determinant = 1.0;
for (int loopdiag = 0; loopdiag < _lArray.Length; ++loopdiag)
{
_determinant *= _lArray[loopdiag][loopdiag] * _lArray[loopdiag][loopdiag];
}
}