Java MatrixUtils.createRealMatrix方法代码示例

import org.apache.commons.math3.linear.MatrixUtils; //导入方法依赖的package包/类
private RealMatrix makeDataMatrix(List<double[]> X, double[] meanX) {
	if (meanX == null) {
		return makeDataMatrix(X);
	}
	final int m = X.size();
	final int n = X.get(0).length;
	RealMatrix M = MatrixUtils.createRealMatrix(n, m);
	RealVector mean = MatrixUtils.createRealVector(meanX);
	int i = 0;
	for (double[] x : X) {
		RealVector xi = MatrixUtils.createRealVector(x).subtract(mean);
		M.setColumnVector(i, xi);
		i++;
	}
	return M;
}
 

import org.apache.commons.math3.linear.MatrixUtils; //导入方法依赖的package包/类
public static RealMatrix concatHorizontally(final RealMatrix left,
        final RealMatrix right) {
    if (left.getRowDimension() != right.getRowDimension()) {
        throw new IllegalArgumentException(
                "The matrices must have the same row dimension!");
    }

    final double[][] result =
            new double[left.getRowDimension()][left.getColumnDimension()
                    + right.getColumnDimension()];

    final int lc = left.getColumnDimension();

    for (int r = 0; r < left.getRowDimension(); r++) {
        for (int c = 0; c < left.getColumnDimension(); c++) {
            result[r][c] = left.getEntry(r, c);
        }
        for (int c = 0; c < right.getColumnDimension(); c++) {
            result[r][lc + c] = right.getEntry(r, c);
        }
    }

    return MatrixUtils.createRealMatrix(result);
}
 

import org.apache.commons.math3.linear.MatrixUtils; //导入方法依赖的package包/类
/**
 * Get the covariance matrix.
 * @return covariance matrix
 */
public RealMatrix getResult() {

    int dimension = sums.length;
    RealMatrix result = MatrixUtils.createRealMatrix(dimension, dimension);

    if (n > 1) {
        double c = 1.0 / (n * (isBiasCorrected ? (n - 1) : n));
        int k = 0;
        for (int i = 0; i < dimension; ++i) {
            for (int j = 0; j <= i; ++j) {
                double e = c * (n * productsSums[k++] - sums[i] * sums[j]);
                result.setEntry(i, j, e);
                result.setEntry(j, i, e);
            }
        }
    }

    return result;

}
 

import org.apache.commons.math3.linear.MatrixUtils; //导入方法依赖的package包/类
public static RealMatrix padSymetricMatrix(RealMatrix inMatrix, Boolean transMatr){
    RealMatrix padedMatrix          = null;
    RealMatrix templateMatrix       = null;

    //transpose if necessary
    if(transMatr) {
        templateMatrix = inMatrix.copy().transpose();
    }else{
        templateMatrix = inMatrix.copy();
    }

    padedMatrix          = MatrixUtils.createRealMatrix(templateMatrix.getRowDimension()+2,
            templateMatrix.getColumnDimension());

    int iPadStart = 1,iPadEnd = padedMatrix.getRowDimension()-1;

    padedMatrix.setRowVector(0,templateMatrix.getRowVector(0));
    padedMatrix.setRowVector(iPadEnd,templateMatrix.getRowVector(templateMatrix.getRowDimension()-1));

    // symetrical padding
    for(int i=iPadStart;i<iPadEnd;i++){
            padedMatrix.setRowVector(i,templateMatrix.getRowVector(i-1));
    }

    return(padedMatrix);
}
 

import org.apache.commons.math3.linear.MatrixUtils; //导入方法依赖的package包/类
public static RealMatrix elementMultiply(RealMatrix inMatrix1,RealMatrix inMatrix2,Boolean absVal){
    int nrows = inMatrix1.getRowDimension();
    int ncols = inMatrix1.getColumnDimension();

    RealMatrix retuRealMatrix = MatrixUtils.createRealMatrix(nrows,ncols);

    for(int i=0;i<nrows;i++){
        for(int j=0;j<ncols;j++){
            if(absVal) {
                retuRealMatrix.setEntry(i, j, Math.abs(inMatrix1.getEntry(i, j) * inMatrix2.getEntry(i, j)));
            }else {
                retuRealMatrix.setEntry(i, j, inMatrix1.getEntry(i, j) * inMatrix2.getEntry(i, j));
            }
        }
    }

    return(retuRealMatrix);
}
 

import org.apache.commons.math3.linear.MatrixUtils; //导入方法依赖的package包/类
public static RealMatrix averageHankelMatrix(RealMatrix hankelMat, int windowSize) {

        int k = hankelMat.getRowDimension();
        int m = hankelMat.getColumnDimension() / windowSize;
        int n = k + windowSize - 1;

        RealMatrix result = MatrixUtils.createRealMatrix(n, m);

        for (int t = 0; t < n; ++t) {
            int i = (t < windowSize) ? 0 : (t - windowSize + 1);
            int j = (t < windowSize) ? t : (windowSize - 1);
            int counter = 0;

            for (; i < k && j >= 0; ++i, --j, ++counter) {
                for (int h = 0; h < m; ++h) {
                    result.addToEntry(t, h, hankelMat.getEntry(i, j * m + h));
                }
            }

            for (int h = 0; h < m; ++h) {
                result.setEntry(t, h, result.getEntry(t, h) / counter);
            }
        }

        return result;
    }
 

import org.apache.commons.math3.linear.MatrixUtils; //导入方法依赖的package包/类
private void solveLinearEquationSystem(double targetDelay, int iterations) {
    driveStrengthMatrix_x = MatrixUtils.createRealMatrix(this.cellInstances.size(), 1);

    for (int i = 0; i < iterations; i++) {
        RealMatrix effortLoadMatrix = this.effortMatrix_T.multiply(driveStrengthMatrix_x);
        driveStrengthMatrix_x = effortLoadMatrix.add(this.staticLoadMatrix_b).scalarMultiply(1 / targetDelay);
    }
}
 

import org.apache.commons.math3.linear.MatrixUtils; //导入方法依赖的package包/类
/**
 * @param A a square matrix.
 * @return the inverse of A or null if A is non-square or singular.
 */
public static double[][] inverse(final double[][] A) {
	RealMatrix M = MatrixUtils.createRealMatrix(A);
	if (!M.isSquare())
		return null;
	else {
		double[][] Ai = null;
		try {
			RealMatrix Mi = MatrixUtils.inverse(M); //new LUDecomposition(M).getSolver().getInverse();
			Ai = Mi.getData();
		} catch (SingularMatrixException e) {}
		return Ai;
	}
}
 

import org.apache.commons.math3.linear.MatrixUtils; //导入方法依赖的package包/类
static double[][] getTruncatedUT(INDArray matrix, int k) {
  double[][] data = getDoubles(matrix);

  SingularValueDecomposition svd = new SingularValueDecomposition(MatrixUtils.createRealMatrix(data));

  double[][] truncatedU = new double[svd.getU().getRowDimension()][k];
  svd.getU().copySubMatrix(0, truncatedU.length - 1, 0, k - 1, truncatedU);
  return truncatedU;
}
 

import org.apache.commons.math3.linear.MatrixUtils; //导入方法依赖的package包/类
@Test
public void testOnes() {
    final RealMatrix expected1 = MatrixUtils.createRealMatrix(
            new double[][] { { 1, 1, 1 }, { 1, 1, 1 }, { 1, 1, 1 } });
    assertEquals(expected1, MatrixFunctions.ones(3, 3));
    final RealMatrix expected2 = MatrixUtils.createRealMatrix(
            new double[][] { { 1, 1 }, { 1, 1 }, { 1, 1 } });
    assertEquals(expected2, MatrixFunctions.ones(3, 2));
    final RealMatrix expected3 = MatrixUtils
            .createRealMatrix(new double[][] { { 1, 1, 1 }, { 1, 1, 1 } });
    assertEquals(expected3, MatrixFunctions.ones(2, 3));
}
 

import org.apache.commons.math3.linear.MatrixUtils; //导入方法依赖的package包/类
@Override
public RealMatrix getTransformationMatrix() {
	RealMatrix cR = R.scalarMultiply(c);
	RealMatrix M = MatrixUtils.createRealMatrix(n, n + 1);
	M.setSubMatrix(cR.getData(), 0, 0);
	M.setColumnVector(n, t);
	return M;
}
 

import org.apache.commons.math3.linear.MatrixUtils; //导入方法依赖的package包/类
@Test
public void testConcatHorizontally() {
    final RealMatrix expected = MatrixUtils
            .createRealMatrix(new double[][] { { 1, 0, 0, 1, 2, 3 },
                    { 0, 1, 0, 1, 2, 3 }, { 0, 0, 1, 1, 2, 3 } });
    assertEquals(expected,
            MatrixFunctions.concatHorizontally(matrixI, matrixA));
}
 

import org.apache.commons.math3.linear.MatrixUtils; //导入方法依赖的package包/类
@Test
public void testConcatVertically() {
    final RealMatrix expected = MatrixUtils
            .createRealMatrix(new double[][] { { 1, 0, 0 }, { 0, 1, 0 },
                    { 0, 0, 1 }, { 1, 2, 3 }, { 1, 2, 3 }, { 1, 2, 3 } });

    assertEquals(expected, MatrixFunctions.concatVertically(matrixI, matrixA));
}
 

import org.apache.commons.math3.linear.MatrixUtils; //导入方法依赖的package包/类
public MultiClassKNFST(final RealMatrix kernelMatrix, final String[] labels)
        throws KNFSTException {
    m_labels = labels;
    // obtain unique class labels
    final ClassWrapper[] classes = ClassWrapper.classes(labels);

    // calculate projection of KNFST
    m_projection = projection(kernelMatrix, labels);

    // calculate target points ( = projections of training data into the
    // null space)
    m_targetPoints = MatrixUtils.createRealMatrix(classes.length,
            m_projection.getColumnDimension());
    int n = 0;
    int nOld = 0;
    for (int c = 0; c < classes.length; c++) {
        n += classes[c].getCount();
        m_targetPoints
                .setRowVector(c,
                        MatrixFunctions
                                .columnMeans(kernelMatrix
                                        .getSubMatrix(nOld, n - 1, 0,
                                                kernelMatrix
                                                        .getColumnDimension()
                                                        - 1)
                                .multiply(m_projection)));
        nOld = n;
    }

    // set betweenClassDistances
    m_betweenClassDistances =
            MatrixFunctions.calculateRowVectorDistances(m_targetPoints);
}
 

import org.apache.commons.math3.linear.MatrixUtils; //导入方法依赖的package包/类
private RealMatrix squared_euclidean_distances(final RealMatrix x,
        final RealMatrix y) {
    final RealMatrix distmat = MatrixUtils
            .createRealMatrix(x.getRowDimension(), y.getRowDimension());

    for (int i = 0; i < x.getRowDimension(); i++) {
        for (int j = 0; j < y.getRowDimension(); j++) {
            final RealVector buff =
                    x.getRowVector(i).subtract(y.getRowVector(j));
            distmat.setEntry(i, j, buff.dotProduct(buff));
        }
    }

    return distmat;
}