@Test(expectedExceptions = IllegalArgumentException.class) public void testNullVector() { CommonsMathWrapper.unwrap((RealVector) null); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testNullRealMatrix() { CommonsMathWrapper.unwrap((RealMatrix) null); }
@Override public DoubleMatrix getTranspose(Matrix m) { ArgChecker.notNull(m, "m"); if (m instanceof DoubleMatrix) { RealMatrix temp = CommonsMathWrapper.wrap((DoubleMatrix) m); return CommonsMathWrapper.unwrap(temp.transpose()); } throw new IllegalArgumentException("Can only find transpose of DoubleMatrix; have " + m.getClass()); }
@Override public DoubleMatrix getPower(Matrix m, int p) { ArgChecker.notNull(m, "m"); RealMatrix temp; if (m instanceof DoubleMatrix) { temp = CommonsMathWrapper.wrap((DoubleMatrix) m); } else { throw new IllegalArgumentException("Can only find powers of DoubleMatrix; have " + m.getClass()); } return CommonsMathWrapper.unwrap(temp.power(p)); }
/** * Constructor. * @param ch The result of the Cholesky decomposition. */ public CholeskyDecompositionCommonsResult(CholeskyDecomposition ch) { ArgChecker.notNull(ch, "Cholesky decomposition"); _determinant = ch.getDeterminant(); _l = CommonsMathWrapper.unwrap(ch.getL()); _lt = CommonsMathWrapper.unwrap(ch.getLT()); _solver = ch.getSolver(); }
/** * Creates an instance. * * @param qr The result of the QR decomposition, not null */ public QRDecompositionCommonsResult(QRDecomposition qr) { ArgChecker.notNull(qr, "qr"); _q = CommonsMathWrapper.unwrap(qr.getQ()); _r = CommonsMathWrapper.unwrap(qr.getR()); _qTranspose = _q.transpose(); _solver = qr.getSolver(); }
@Override public DoubleMatrix getOuterProduct(Matrix m1, Matrix m2) { ArgChecker.notNull(m1, "m1"); ArgChecker.notNull(m2, "m2"); if (m1 instanceof DoubleArray && m2 instanceof DoubleArray) { RealVector t1 = CommonsMathWrapper.wrap((DoubleArray) m1); RealVector t2 = CommonsMathWrapper.wrap((DoubleArray) m2); return CommonsMathWrapper.unwrap(t1.outerProduct(t2)); } throw new IllegalArgumentException("Can only find outer product of DoubleArray; have " + m1.getClass() + " and " + m2.getClass()); }
/** * {@inheritDoc} */ @Override public DoubleArray solve(DoubleArray b) { ArgChecker.notNull(b, "b"); return CommonsMathWrapper.unwrap(_solver.solve(CommonsMathWrapper.wrap(b))); }
/** * Creates an instance. * * @param svd The result of the SV decomposition, not null */ public SVDecompositionCommonsResult(SingularValueDecomposition svd) { ArgChecker.notNull(svd, "svd"); _condition = svd.getConditionNumber(); _norm = svd.getNorm(); _rank = svd.getRank(); _s = CommonsMathWrapper.unwrap(svd.getS()); _singularValues = svd.getSingularValues(); _u = CommonsMathWrapper.unwrap(svd.getU()); _uTranspose = CommonsMathWrapper.unwrap(svd.getUT()); _v = CommonsMathWrapper.unwrap(svd.getV()); _vTranspose = CommonsMathWrapper.unwrap(svd.getVT()); _solver = svd.getSolver(); }
/** * {@inheritDoc} */ @Override public DoubleMatrix solve(DoubleMatrix b) { ArgChecker.notNull(b, "b"); return CommonsMathWrapper.unwrap(_solver.solve(CommonsMathWrapper.wrap(b))); }
/** * {@inheritDoc} */ @Override public DoubleMatrix solve(DoubleMatrix b) { ArgChecker.notNull(b, "b"); return CommonsMathWrapper.unwrap(_solver.solve(CommonsMathWrapper.wrap(b))); }
@Override public DoubleMatrix getInverse(Matrix m) { ArgChecker.notNull(m, "matrix was null"); if (m instanceof DoubleMatrix) { RealMatrix temp = CommonsMathWrapper.wrap((DoubleMatrix) m); SingularValueDecomposition sv = new SingularValueDecomposition(temp); RealMatrix inv = sv.getSolver().getInverse(); return CommonsMathWrapper.unwrap(inv); } throw new IllegalArgumentException("Can only find inverse of DoubleMatrix; have " + m.getClass()); }
/** * {@inheritDoc} */ @Override public DoubleArray solve(DoubleArray b) { ArgChecker.notNull(b, "b"); return CommonsMathWrapper.unwrap(_solver.solve(CommonsMathWrapper.wrap(b))); }
/** * {@inheritDoc} */ @Override public DoubleMatrix solve(DoubleMatrix b) { ArgChecker.notNull(b, "b"); return CommonsMathWrapper.unwrap(_solver.solve(CommonsMathWrapper.wrap(b))); }
/** * {@inheritDoc} */ @Override public DoubleArray solve(DoubleArray b) { ArgChecker.notNull(b, "b"); return CommonsMathWrapper.unwrap(_solver.solve(CommonsMathWrapper.wrap(b))); }
/** * {@inheritDoc} */ @Override public DoubleArray solve(DoubleArray b) { ArgChecker.notNull(b, "b"); return CommonsMathWrapper.unwrap(_solver.solve(CommonsMathWrapper.wrap(b))); }
/** * {@inheritDoc} */ @Override public DoubleMatrix solve(DoubleMatrix b) { ArgChecker.notNull(b, "b"); return CommonsMathWrapper.unwrap(_solver.solve(CommonsMathWrapper.wrap(b))); } }
/** * Creates an instance. * * @param lu The result of the LU decomposition, not null. $\mathbf{L}$ cannot be singular. */ public LUDecompositionCommonsResult(LUDecomposition lu) { ArgChecker.notNull(lu, "LU decomposition"); ArgChecker.notNull(lu.getL(), "Matrix is singular; could not perform LU decomposition"); _determinant = lu.getDeterminant(); _l = CommonsMathWrapper.unwrap(lu.getL()); _p = CommonsMathWrapper.unwrap(lu.getP()); _pivot = lu.getPivot(); _solver = lu.getSolver(); _u = CommonsMathWrapper.unwrap(lu.getU()); }
@Test public void testVector() { RealVector commons = CommonsMathWrapper.wrap(OG_VECTOR); assertEquals(CommonsMathWrapper.unwrap(commons), OG_VECTOR); }
@Test public void testMatrix() { RealMatrix commons = CommonsMathWrapper.wrap(OG_MATRIX); double[][] unwrapped = CommonsMathWrapper.unwrap(commons).toArray(); double[][] ogData = OG_MATRIX.toArray(); int n = unwrapped.length; assertEquals(n, ogData.length); for (int i = 0; i < n; i++) { assertArrayEquals(unwrapped[i], ogData[i], 1e-15); } }