/** * Returns the quasi-triangular Schur matrix T of the transform. * * @return the T matrix */ public RealMatrix getT() { if (cachedT == null) { cachedT = MatrixUtils.createRealMatrix(matrixT); } // return the cached matrix return cachedT; }
/** * {@inheritDoc} * @throws SingularMatrixException if the decomposed matrix is singular. */ public RealMatrix getInverse() { return solve(MatrixUtils.createRealIdentityMatrix(qrt[0].length)); } }
/** * Returns the diagonal matrix Σ of the decomposition. * <p>Σ is a diagonal matrix. The singular values are provided in * non-increasing order, for compatibility with Jama.</p> * @return the Σ matrix */ public RealMatrix getS() { if (cachedS == null) { // cache the matrix for subsequent calls cachedS = MatrixUtils.createRealDiagonalMatrix(singularValues); } return cachedS; }
@Override public FunkSVDModel get() { int userCount = snapshot.getUserIds().size(); RealMatrix userFeatures = MatrixUtils.createRealMatrix(userCount, featureCount); RealMatrix itemFeatures = MatrixUtils.createRealMatrix(itemCount, featureCount); RealVector uvec = MatrixUtils.createRealVector(new double [userCount]); RealVector ivec = MatrixUtils.createRealVector(new double[itemCount]);
private Pair<double[], double[]> calculatePixelLookupTable(DicomImageElement dicomImage) { double deltaI = dicomImage.getSliceGeometry().getVoxelSpacingArray()[0]; double deltaJ = dicomImage.getSliceGeometry().getVoxelSpacingArray()[1]; double[] rowDirection = dicomImage.getSliceGeometry().getRowArray(); double[] columnDirection = dicomImage.getSliceGeometry().getColumnArray(); double[] position = dicomImage.getSliceGeometry().getTLHCArray(); // DICOM C.7.6.2.1 Equation C.7.6.2.1-1. double[][] m = { { rowDirection[0] * deltaI, columnDirection[0] * deltaJ, 0, position[0] }, { rowDirection[1] * deltaI, columnDirection[1] * deltaJ, 0, position[1] }, { rowDirection[2] * deltaI, columnDirection[2] * deltaJ, 0, position[2] }, { 0, 0, 0, 1 } }; RealMatrix matrix = MatrixUtils.createRealMatrix(m); double[] x = new double[dicomImage.getImage().width()]; // column index to the image plane. for (int i = 0; i < dicomImage.getImage().width(); i++) { x[i] = matrix.multiply(MatrixUtils.createColumnRealMatrix(new double[] { i, 0, 0, 1 })).getRow(0)[0]; } double[] y = new double[dicomImage.getImage().height()]; // row index to the image plane for (int j = 0; j < dicomImage.getImage().height(); j++) { y[j] = matrix.multiply(MatrixUtils.createColumnRealMatrix(new double[] { 0, j, 0, 1 })).getRow(1)[0]; } return new Pair<>(x, y); }
public void updateCoefficients(double l2penalty) { if (this.X_svd == null) { this.X_svd = new SingularValueDecomposition(X); } RealMatrix V = this.X_svd.getV(); double[] s = this.X_svd.getSingularValues(); RealMatrix U = this.X_svd.getU(); for (int i = 0; i < s.length; i++) { s[i] = s[i] / (s[i]*s[i] + l2penalty); } RealMatrix S = MatrixUtils.createRealDiagonalMatrix(s); RealMatrix Z = V.multiply(S).multiply(U.transpose()); this.coefficients = Z.operate(this.Y); this.fitted = this.X.operate(this.coefficients); double errorVariance = 0; for (int i = 0; i < residuals.length; i++) { this.residuals[i] = this.Y[i] - this.fitted[i]; errorVariance += this.residuals[i] * this.residuals[i]; } errorVariance = errorVariance / (X.getRowDimension() - X.getColumnDimension()); RealMatrix errorVarianceMatrix = MatrixUtils.createRealIdentityMatrix(this.Y.length).scalarMultiply(errorVariance); RealMatrix coefficientsCovarianceMatrix = Z.multiply(errorVarianceMatrix).multiply(Z.transpose()); this.standarderrors = getDiagonal(coefficientsCovarianceMatrix); }
/** * Returns the result of postmultiplying {@code this} by {@code m}. * * @param m matrix to postmultiply by * @return {@code this * m} * @throws DimensionMismatchException if * {@code columnDimension(this) != rowDimension(m)} */ public DiagonalMatrix multiply(final DiagonalMatrix m) throws DimensionMismatchException { MatrixUtils.checkMultiplicationCompatible(this, m); final int dim = getRowDimension(); final double[] outData = new double[dim]; for (int i = 0; i < dim; i++) { outData[i] = data[i] * m.data[i]; } return new DiagonalMatrix(outData, false); }
(1 - 1 / ((double) 4 * dimension) + 1 / ((double) 21 * dimension * dimension)); xmean = MatrixUtils.createColumnRealMatrix(guess); // objective variables diagD = insigma.scalarMultiply(1 / sigma); diagC = square(diagD);
/** {@inheritDoc} */ @Override public RealVector preMultiply(final RealVector v) throws DimensionMismatchException { final double[] vectorData; if (v instanceof ArrayRealVector) { vectorData = ((ArrayRealVector) v).getDataRef(); } else { vectorData = v.toArray(); } return MatrixUtils.createRealVector(preMultiply(vectorData)); }
/** * Computes the inverse of the given matrix. * <p> * By default, the inverse of the matrix is computed using the QR-decomposition, * unless a more efficient method can be determined for the input matrix. * <p> * Note: this method will use a singularity threshold of 0, * use {@link #inverse(RealMatrix, double)} if a different threshold is needed. * * @param matrix Matrix whose inverse shall be computed * @return the inverse of {@code matrix} * @throws NullArgumentException if {@code matrix} is {@code null} * @throws SingularMatrixException if m is singular * @throws NonSquareMatrixException if matrix is not square * @since 3.3 */ public static RealMatrix inverse(RealMatrix matrix) throws NullArgumentException, SingularMatrixException, NonSquareMatrixException { return inverse(matrix, 0); }
RealMatrix eTheta = MatrixUtils.createRealMatrix(userNum, featureCount); RealMatrix eBeta = MatrixUtils.createRealMatrix(itemNum, featureCount); for (int user = 0; user < userNum; user++) { RealVector eThetaU = MatrixUtils.createRealVector(new double[featureCount]); for (int k = 0; k < featureCount; k++) { double gammaShpUK = preUserModel.getWeightShpEntry(user, k); RealVector eBetaI = MatrixUtils.createRealVector(new double[featureCount]); for (int k = 0; k < featureCount; k++) { double lambdaShpIK = preItemModel.getWeightShpEntry(item, k);
public void updateCoefficients(double l2penalty) { if (this.X_svd == null) { this.X_svd = new SingularValueDecomposition(X); } RealMatrix V = this.X_svd.getV(); double[] s = this.X_svd.getSingularValues(); RealMatrix U = this.X_svd.getU(); for (int i = 0; i < s.length; i++) { s[i] = s[i] / (s[i]*s[i] + l2penalty); } RealMatrix S = MatrixUtils.createRealDiagonalMatrix(s); RealMatrix Z = V.multiply(S).multiply(U.transpose()); this.coefficients = Z.operate(this.Y); this.fitted = this.X.operate(this.coefficients); double errorVariance = 0; for (int i = 0; i < residuals.length; i++) { this.residuals[i] = this.Y[i] - this.fitted[i]; errorVariance += this.residuals[i] * this.residuals[i]; } errorVariance = errorVariance / (X.getRowDimension() - X.getColumnDimension()); RealMatrix errorVarianceMatrix = MatrixUtils.createRealIdentityMatrix(this.Y.length).scalarMultiply(errorVariance); RealMatrix coefficientsCovarianceMatrix = Z.multiply(errorVarianceMatrix).multiply(Z.transpose()); this.standarderrors = getDiagonal(coefficientsCovarianceMatrix); }
protected double[][] evaluate(double[][] d1, double[][] d2) throws EvaluationException{ Array2DRowRealMatrix first = new Array2DRowRealMatrix(d1); Array2DRowRealMatrix second = new Array2DRowRealMatrix(d2); try { MatrixUtils.checkMultiplicationCompatible(first, second); } catch (DimensionMismatchException e) { throw new EvaluationException(ErrorEval.VALUE_INVALID); } return first.multiply(second).getData(); } };
(1 - 1 / ((double) 4 * dimension) + 1 / ((double) 21 * dimension * dimension)); xmean = MatrixUtils.createColumnRealMatrix(guess); // objective variables diagD = insigma.scalarMultiply(1 / sigma); diagC = square(diagD);
public FunkSVDModel(RealMatrix umat, RealMatrix imat, KeyIndex uidx, KeyIndex iidx, List<FeatureInfo> features) { super(umat, imat, uidx, iidx); featureInfo = ImmutableList.copyOf(features); double[] means = new double[featureCount]; for (int f = featureCount - 1; f >= 0; f--) { means[f] = featureInfo.get(f).getUserAverage(); } averageUser = MatrixUtils.createRealVector(means); }
protected double[][] evaluate(double[][] d1) throws EvaluationException { if (d1.length != d1[0].length) { throw new EvaluationException(ErrorEval.VALUE_INVALID); } Array2DRowRealMatrix temp = new Array2DRowRealMatrix(d1); return MatrixUtils.inverse(temp).getData(); } };
/** * Create a KendallsCorrelation from a rectangular array * whose columns represent values of variables to be correlated. * * @param data rectangular array with columns representing variables * @throws IllegalArgumentException if the input data array is not * rectangular with at least two rows and two columns. */ public KendallsCorrelation(double[][] data) { this(MatrixUtils.createRealMatrix(data)); }
final double tauShpI = cPrime + featureCount * c; RealMatrix gammaShp = MatrixUtils.createRealMatrix(userNum, featureCount); RealMatrix gammaRte = MatrixUtils.createRealMatrix(userNum, featureCount); RealVector kappaShp = MatrixUtils.createRealVector(new double[userNum]); RealVector kappaRte = MatrixUtils.createRealVector(new double[userNum]); RealMatrix lambdaShp = MatrixUtils.createRealMatrix(itemNum, featureCount); RealMatrix lambdaRte = MatrixUtils.createRealMatrix(itemNum, featureCount); RealVector tauShp = MatrixUtils.createRealVector(new double[itemNum]); RealVector tauRte = MatrixUtils.createRealVector(new double[itemNum]); RealMatrix gammaShpNext = MatrixUtils.createRealMatrix(userNum, featureCount); RealMatrix lambdaShpNext = MatrixUtils.createRealMatrix(itemNum, featureCount); gammaShpNext = gammaShpNext.scalarAdd(a); lambdaShpNext = lambdaShpNext.scalarAdd(c); RealVector phiUI = MatrixUtils.createRealVector(new double[featureCount]); RealVector gammaRteSecondTerm = MatrixUtils.createRealVector(new double[featureCount]); for (int k = 0; k < featureCount; k++) { double gammaRteUK = 0.0; RealVector lambdaRteSecondTerm = MatrixUtils.createRealVector(new double[featureCount]); for (int k = 0; k < featureCount; k++) { double lambdaRteIK = 0.0; RealMatrix eTheta = MatrixUtils.createRealMatrix(userNum, featureCount); RealMatrix eBeta = MatrixUtils.createRealMatrix(itemNum, featureCount); for (int user = 0; user < userNum; user++) { RealVector gammaShpU = gammaShp.getRowVector(user);
/** * Get the inverse of the decomposed matrix. * * @return the inverse matrix. * @throws SingularMatrixException if the decomposed matrix is singular. */ public RealMatrix getInverse() { return solve(MatrixUtils.createRealIdentityMatrix(pivot.length)); } }
/** * Gets the block diagonal matrix D of the decomposition. * D is a block diagonal matrix. * Real eigenvalues are on the diagonal while complex values are on * 2x2 blocks { {real +imaginary}, {-imaginary, real} }. * * @return the D matrix. * * @see #getRealEigenvalues() * @see #getImagEigenvalues() */ public RealMatrix getD() { if (cachedD == null) { // cache the matrix for subsequent calls cachedD = MatrixUtils.createRealDiagonalMatrix(realEigenvalues); for (int i = 0; i < imagEigenvalues.length; i++) { if (Precision.compareTo(imagEigenvalues[i], 0.0, EPSILON) > 0) { cachedD.setEntry(i, i+1, imagEigenvalues[i]); } else if (Precision.compareTo(imagEigenvalues[i], 0.0, EPSILON) < 0) { cachedD.setEntry(i, i-1, imagEigenvalues[i]); } } } return cachedD; }