/// <summary> /// Compute $A^T A$, where A is a matrix. </summary> /// <param name="a"> The matrix </param> /// <returns> The result of $A^T A$ </returns> public virtual DoubleMatrix matrixTransposeMultiplyMatrix(DoubleMatrix a) { ArgChecker.notNull(a, "a"); int n = a.rowCount(); int m = a.columnCount(); //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); for (int i = 0; i < m; i++) { double sum = 0d; for (int k = 0; k < n; k++) { sum += a.get(k, i) * a.get(k, i); } data[i][i] = sum; for (int j = i + 1; j < m; j++) { sum = 0d; for (int k = 0; k < n; k++) { sum += a.get(k, i) * a.get(k, j); } data[i][j] = sum; data[j][i] = sum; } } return(DoubleMatrix.ofUnsafe(data)); }
/// <summary> /// Finds the node sensitivity. /// </summary> /// <param name="pp"> the <seealso cref="PiecewisePolynomialResultsWithSensitivity"/> </param> /// <param name="xKey"> the key </param> /// <returns> Node sensitivity value at x=xKey </returns> public virtual DoubleArray nodeSensitivity(PiecewisePolynomialResultsWithSensitivity pp, double xKey) { ArgChecker.notNull(pp, "null pp"); ArgChecker.isFalse(double.IsNaN(xKey), "xKey containing NaN"); ArgChecker.isFalse(double.IsInfinity(xKey), "xKey containing Infinity"); if (pp.Dimensions > 1) { throw new System.NotSupportedException(); } DoubleArray knots = pp.Knots; int nKnots = knots.size(); int interval = FunctionUtils.getLowerBoundIndex(knots, xKey); if (interval == nKnots - 1) { interval--; // there is 1 less interval that knots } double s = xKey - knots.get(interval); DoubleMatrix a = pp.getCoefficientSensitivity(interval); int nCoefs = a.rowCount(); DoubleArray res = a.row(0); for (int i = 1; i < nCoefs; i++) { res = (DoubleArray)MA.scale(res, s); res = (DoubleArray)MA.add(res, a.row(i)); } return(res); }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: @Override public com.opengamma.strata.collect.array.DoubleMatrix[] solveMultiDim(final double[] xValues, final com.opengamma.strata.collect.array.DoubleMatrix yValuesMatrix) public override DoubleMatrix[] solveMultiDim(double[] xValues, DoubleMatrix yValuesMatrix) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int dim = yValuesMatrix.rowCount(); int dim = yValuesMatrix.rowCount(); DoubleMatrix[] coefMatrix = new DoubleMatrix[dim]; for (int i = 0; i < dim; ++i) { coefMatrix[i] = solve(xValues, yValuesMatrix.row(i).toArray()); } return(coefMatrix); }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: private void assertMatrixEquals(final com.opengamma.strata.collect.array.Matrix m1, final com.opengamma.strata.collect.array.Matrix m2) private void assertMatrixEquals(Matrix m1, Matrix m2) { if (m1 is DoubleArray) { assertTrue(m2 is DoubleArray); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleArray m3 = (com.opengamma.strata.collect.array.DoubleArray) m1; DoubleArray m3 = (DoubleArray)m1; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleArray m4 = (com.opengamma.strata.collect.array.DoubleArray) m2; DoubleArray m4 = (DoubleArray)m2; assertEquals(m3.size(), m4.size()); for (int i = 0; i < m3.size(); i++) { assertEquals(m3.get(i), m4.get(i), EPS); } return; } if (m2 is DoubleMatrix) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleMatrix m3 = (com.opengamma.strata.collect.array.DoubleMatrix) m1; DoubleMatrix m3 = (DoubleMatrix)m1; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleMatrix m4 = (com.opengamma.strata.collect.array.DoubleMatrix) m2; DoubleMatrix m4 = (DoubleMatrix)m2; assertEquals(m3.size(), m4.size()); assertEquals(m3.rowCount(), m4.rowCount()); assertEquals(m3.columnCount(), m4.columnCount()); for (int i = 0; i < m3.rowCount(); i++) { for (int j = 0; j < m3.columnCount(); j++) { assertEquals(m3.get(i, j), m4.get(i, j), EPS); } } } }
public LeastSquareResults(double chiSq, DoubleArray parameters, DoubleMatrix covariance, DoubleMatrix inverseJacobian) { ArgChecker.isTrue(chiSq >= 0, "chi square < 0"); ArgChecker.notNull(parameters, "parameters"); ArgChecker.notNull(covariance, "covariance"); int n = parameters.size(); ArgChecker.isTrue(covariance.columnCount() == n, "covariance matrix not square"); ArgChecker.isTrue(covariance.rowCount() == n, "covariance matrix wrong size"); //TODO test size of inverse Jacobian _chiSq = chiSq; _parameters = parameters; _covariance = covariance; _inverseJacobian = inverseJacobian; }
/// <summary> /// Assert that two matrices (as <seealso cref="DoubleMatrix"/>) equal concerning a delta. To be equal the matrices /// must be the same size, and each element must match to within delta. /// If they are not equal an AssertionFailedError is thrown. </summary> /// <param name="m1"> expected matrix </param> /// <param name="m2"> actual matrix </param> /// <param name="delta"> the allowed difference between the elements </param> public static void assertEqualsMatrix(DoubleMatrix m1, DoubleMatrix m2, double delta) { ArgChecker.notNull(m1, "m1"); ArgChecker.notNull(m2, "m2"); int rows = m1.rowCount(); int cols = m1.columnCount(); assertEquals("Number of rows:", rows, m2.rowCount()); assertEquals("Number of columns:", cols, m2.columnCount()); for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { assertEquals("", m1.get(i, j), m2.get(i, j), delta); } } }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: private void checkEquals(final com.opengamma.strata.collect.array.DoubleMatrix x, final com.opengamma.strata.collect.array.DoubleMatrix y) private void checkEquals(DoubleMatrix x, DoubleMatrix y) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int n = x.rowCount(); int n = x.rowCount(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int m = x.columnCount(); int m = x.columnCount(); assertEquals(n, y.rowCount()); assertEquals(m, y.columnCount()); for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { assertEquals(x.get(i, j), y.get(i, j), EPS); } } }
public static void notNaNOrInfinite(DoubleMatrix x) { int rows = x.rowCount(); int cols = x.columnCount(); for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { double temp = x.get(i, j); if (double.IsNaN(temp)) { throw new MathException("Matrix contains a NaN"); } if (double.IsInfinity(temp)) { throw new MathException("Matrix contains an infinite"); } } } }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: private void checkIdentity(final com.opengamma.strata.collect.array.DoubleMatrix x) private void checkIdentity(DoubleMatrix x) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int n = x.rowCount(); int n = x.rowCount(); assertEquals(x.columnCount(), n); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (i == j) { assertEquals(1.0, x.get(i, i), EPS); } else { assertEquals(0.0, x.get(i, j), EPS); } } } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testInvert() public virtual void testInvert() { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleMatrix res = CALCULATOR.apply(MATRIX); DoubleMatrix res = CALCULATOR.apply(MATRIX); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final com.opengamma.strata.collect.array.DoubleMatrix idet = (com.opengamma.strata.collect.array.DoubleMatrix) OG_ALGEBRA.multiply(TRI, res); DoubleMatrix idet = (DoubleMatrix)OG_ALGEBRA.multiply(TRI, res); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int n = idet.rowCount(); int n = idet.rowCount(); int i, j; for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { assertEquals((i == j ? 1.0 : 0.0), idet.get(i, j), EPS); } } }
/// <summary> /// Returns the Kronecker product of two matrices. If $\mathbf{A}$ is an $m /// \times n$ matrix and $\mathbf{B}$ is a $p \times q$ matrix, then the /// Kronecker product $A \otimes B$ is an $mp \times nq$ matrix with elements /// $$ /// \begin{align*} /// A \otimes B &= /// \begin{pmatrix} /// a_{11}\mathbf{B} & \cdots & a_{1n}\mathbf{B} \\ /// \vdots & \ddots & \vdots \\ /// a_{m1}\mathbf{B} & \cdots & a_{mn}\mathbf{B} /// \end{pmatrix}\\ /// &= /// \begin{pmatrix} /// a_{11}b_{11} & a_{11}b_{12} & \cdots & a_{11}b_{1q} & \cdots & a_{1n}b_{11} & a_{1n}b_{12} & \cdots & a_{1n}b_{1q}\\ /// a_{11}b_{21} & a_{11}b_{22} & \cdots & a_{11}b_{2q} & \cdots & a_{1n}b_{21} & a_{1n}b_{22} & \cdots & a_{1n}b_{2q} \\ /// \vdots & \vdots & \ddots & \vdots & \cdots & \vdots & \vdots & \ddots & \cdots \\ /// a_{11}b_{p1} & a_{11}b_{p2} & \cdots & a_{11}b_{pq} & \cdots & a_{1n}b_{p1} & a_{1n}b_{p2} & \cdots & a_{1n}b_{pq} \\ /// \vdots & \vdots & & \vdots & \ddots & \vdots & \vdots & & \cdots \\ /// a_{m1}b_{11} & a_{m1}b_{12} & \cdots & a_{m1}b_{1q} & \cdots & a_{mn}b_{11} & a_{mn}b_{12} & \cdots & a_{mn}b_{1q} \\ /// a_{m1}b_{21} & a_{m1}b_{22} & \cdots & a_{m1}b_{2q} & \cdots & a_{mn}b_{21} & a_{mn}b_{22} & \cdots & a_{mn}b_{2q} \\ /// \vdots & \vdots & \ddots & \vdots & \cdots & \vdots & \vdots & \ddots & \cdots \\ /// a_{m1}b_{p1} & a_{m1}b_{p2} & \cdots & a_{m1}b_{pq} & \cdots & a_{mn}b_{p1} & a_{mn}b_{p2} & \cdots & a_{mn}b_{pq} /// \end{pmatrix} /// \end{align*} /// $$ </summary> /// <param name="m1"> The first matrix, not null. This matrix must be a <seealso cref="DoubleMatrix"/>. </param> /// <param name="m2"> The second matrix, not null. This matrix must be a <seealso cref="DoubleMatrix"/>. </param> /// <returns> The Kronecker product </returns> public virtual Matrix kroneckerProduct(Matrix m1, Matrix m2) { ArgChecker.notNull(m1, "m1"); ArgChecker.notNull(m2, "m2"); if (m1 is DoubleMatrix && m2 is DoubleMatrix) { DoubleMatrix matrix1 = (DoubleMatrix)m1; DoubleMatrix matrix2 = (DoubleMatrix)m2; int aRows = matrix1.rowCount(); int aCols = matrix1.columnCount(); int bRows = matrix2.rowCount(); int bCols = matrix2.columnCount(); int rRows = aRows * bRows; int rCols = aCols * bCols; //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[][] res = new double[rRows][rCols]; double[][] res = RectangularArrays.ReturnRectangularDoubleArray(rRows, rCols); for (int i = 0; i < aRows; i++) { for (int j = 0; j < aCols; j++) { double t = matrix1.get(i, j); if (t != 0.0) { for (int k = 0; k < bRows; k++) { for (int l = 0; l < bCols; l++) { res[i * bRows + k][j * bCols + l] = t * matrix2.get(k, l); } } } } } return(DoubleMatrix.ofUnsafe(res)); } throw new System.ArgumentException("Can only calculate the Kronecker product of two DoubleMatrix."); }
/// <summary> /// Interpolate. /// </summary> /// <param name="xValues"> the values </param> /// <param name="yValuesMatrix"> the matrix </param> /// <param name="x"> the x </param> /// <returns> Values of the underlying cubic spline functions interpolating {yValuesMatrix.RowVectors} at the value of x </returns> //JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: public com.opengamma.strata.collect.array.DoubleArray interpolate(final double[] xValues, final double[][] yValuesMatrix, final double x) public virtual DoubleArray interpolate(double[] xValues, double[][] yValuesMatrix, double x) { DoubleMatrix matrix = DoubleMatrix.copyOf(yValuesMatrix); return(DoubleArray.of(matrix.rowCount(), i => interpolate(xValues, matrix.rowArray(i), x))); }