Java DenseMatrix.numColumns方法代码示例

import no.uib.cipr.matrix.DenseMatrix; //导入方法依赖的package包/类
public void ignoredTimedTransMult() {
    Stopwatch watch = Stopwatch.createUnstarted();
    DenseMatrix dense = new DenseMatrix(1000, 1000);
    int[][] nz = Utilities.getRowPattern(dense.numRows(),
            dense.numColumns(), 100);
    Utilities.rowPopulate(dense, nz);
    log.info("created matrices");
    Matrix sparse = new LinkedSparseMatrix(dense.numRows(),
            dense.numColumns());
    sparse.set(dense);

    for (Matrix m : Lists.newArrayList(dense, sparse)) {
        log.info("starting " + m.getClass());
        Matrix t = new DenseMatrix(m);
        Matrix o = new DenseMatrix(dense.numRows(), dense.numColumns());
        log.info("warming up " + m.getClass() + " " + o.getClass());
        for (int i = 0; i < 10; i++)
            m.transAmult(t, o);
        log.info("starting " + m.getClass() + " " + o.getClass());
        watch.start();
        for (int i = 0; i < 100; i++)
            m.transAmult(t, o);
        watch.stop();
        log.info(m.getClass() + " " + o.getClass() + " " + watch);
    }
}
 

import no.uib.cipr.matrix.DenseMatrix; //导入方法依赖的package包/类
public Matrix mtimes(Matrix m2) {
	if (m2 instanceof MTJDenseDoubleMatrix2D) {
		DenseMatrix a = matrix;
		DenseMatrix b = ((MTJDenseDoubleMatrix2D) m2).getWrappedObject();
		DenseMatrix c = new DenseMatrix(a.numRows(), b.numColumns());
		// try {
		a.mult(b, c);
		return new MTJDenseDoubleMatrix2D(c);
		// } catch (Exception e) {
		// // sometimes BLAS cannot be found. Don't know why. Use direct
		// // method instead.
		// double[] Bd = ((DenseMatrix) b).getData(), Cd = ((DenseMatrix)
		// c).getData();
		// org.netlib.blas.Dgemm.dgemm("N", "N", c.numRows(),
		// c.numColumns(), a.numColumns(), 1, a.getData(), 0,
		// Math.max(1, a.numRows()), Bd, 0, Math.max(1, b.numRows()), 1, Cd,
		// 0, Math.max(1, c.numRows()));
		// return new MTJDenseDoubleMatrix2D(c);
		// }
	}
	return super.mtimes(m2);
}
 

import no.uib.cipr.matrix.DenseMatrix; //导入方法依赖的package包/类
public static DenseMatrix multBLASAdd(double alpha, DenseMatrix B, DenseMatrix C) {

        double[] Bd = B.getData(), Cd = C.getData();
        int CRows = C.numRows();
        int cCols = C.numColumns();
        int BRows = B.numRows();
        int bCols = B.numColumns();


        BLAS.getInstance().dgemm("N", "N",
                C.numRows(), C.numColumns(),
                B.numColumns(), alpha,
                Bd,
                Math.max(1, B.numRows()), Bd, Math.max(1, B.numRows()), 0.0, Cd,
                Math.max(1, C.numRows()));

        return C;
    }
 

import no.uib.cipr.matrix.DenseMatrix; //导入方法依赖的package包/类
private double sumLogFactorial(DenseMatrix fv) {
	double sum = 0;
	final double[] data = fv.getData();
	for (int i = 0; i < fv.numColumns(); i++) {
		final int fvi = (int) data[i];
		if (logFacCache.contains(fvi))
		{
			sum += logFacCache.get(fvi);
		}
		else {
			for (int j = 1; j < fvi + 1; j++) {
				sum += Math.log(j);
			}
		}
	}
	return sum;
}
 

import no.uib.cipr.matrix.DenseMatrix; //导入方法依赖的package包/类
public void ignoredTimedMult() {
    Stopwatch watch = Stopwatch.createUnstarted();
    DenseMatrix dense = new DenseMatrix(1000, 1000);
    int[][] nz = Utilities.getRowPattern(dense.numRows(),
            dense.numColumns(), 100);
    Utilities.rowPopulate(dense, nz);
    log.info("created matrices");
    Matrix sparse = new LinkedSparseMatrix(dense.numRows(),
            dense.numColumns());
    sparse.set(dense);

    for (Matrix m : Lists.newArrayList(dense, sparse)) {
        log.info("starting " + m.getClass());
        Matrix t = new DenseMatrix(m);
        t.transpose();
        Matrix o = new DenseMatrix(dense.numRows(), dense.numColumns());
        log.info("warming up " + m.getClass() + " " + o.getClass());
        for (int i = 0; i < 10; i++)
            m.mult(t, o);
        log.info("starting " + m.getClass() + " " + o.getClass());
        watch.start();
        for (int i = 0; i < 100; i++)
            m.mult(t, o);
        watch.stop();
        log.info(m.getClass() + " " + o.getClass() + " " + watch);
    }
}
 

import no.uib.cipr.matrix.DenseMatrix; //导入方法依赖的package包/类
/**
 * Reduce the rank a matrix by estimating a the best (in a least-squares
 * sense) approximation using the thin SVD.
 * 
 * @param m
 *            the matrix to reduce.
 * @param rank
 *            the desired rank.
 * @return the rank-reduced matrix.
 */
public static Matrix reduceRank(Matrix m, int rank) {
	if (rank > Math.min(m.getColumnDimension(), m.getRowDimension())) {
		return m;
	}

	final no.uib.cipr.matrix.DenseMatrix mjtA = new no.uib.cipr.matrix.DenseMatrix(
			m.getArray());
	no.uib.cipr.matrix.SVD svd;
	try {
		svd = no.uib.cipr.matrix.SVD.factorize(mjtA);
	} catch (final NotConvergedException e) {
		throw new RuntimeException(e);
	}

	final DenseMatrix U = svd.getU();
	final DenseMatrix Vt = svd.getVt();
	final double[] svector = svd.getS();
	final DenseMatrix S = new DenseMatrix(U.numColumns(), Vt.numRows());
	for (int i = 0; i < rank; i++)
		S.set(i, i, svector[i]);

	final DenseMatrix C = new DenseMatrix(U.numRows(), S.numColumns());
	final DenseMatrix out = new DenseMatrix(C.numRows(), Vt.numColumns());
	U.mult(S, C);
	C.mult(Vt, out);

	final Matrix outFinal = convert(out);
	return outFinal;
}
 

import no.uib.cipr.matrix.DenseMatrix; //导入方法依赖的package包/类
public void setMatrix(Matrix A) {
    List<CompRowMatrix> Al = new LinkedList<CompRowMatrix>();
    List<CompColMatrix> Il = new LinkedList<CompColMatrix>();

    Al.add(new CompRowMatrix(A));

    for (int k = 0; Al.get(k).numRows() > min; ++k) {

        CompRowMatrix Af = Al.get(k);

        double eps = 0.08 * Math.pow(0.5, k);

        // Create the aggregates
        Aggregator aggregator = new Aggregator(Af, eps);

        // If no aggregates were created, no interpolation operator will be
        // created, and the setup phase stops
        if (aggregator.getAggregates().isEmpty())
            break;

        // Create an interpolation operator using smoothing. This also
        // creates the Galerkin operator
        Interpolator sa = new Interpolator(aggregator, Af, omega);

        Al.add(sa.getGalerkinOperator());
        Il.add(sa.getInterpolationOperator());
    }

    // Copy to array storage
    m = Al.size();
    if (m == 0)
        throw new RuntimeException("Matrix too small for AMG");

    I = new CompColMatrix[m - 1];
    this.A = new CompRowMatrix[m - 1];

    Il.toArray(I);
    for (int i = 0; i < Al.size() - 1; ++i)
        this.A[i] = Al.get(i);

    // Create a LU decomposition of the smallest Galerkin matrix
    DenseMatrix Ac = new DenseMatrix(Al.get(Al.size() - 1));
    lu = new DenseLU(Ac.numRows(), Ac.numColumns());
    lu.factor(Ac);

    // Allocate vectors at each level
    u = new DenseVector[m];
    f = new DenseVector[m];
    r = new DenseVector[m];
    for (int k = 0; k < m; ++k) {
        int n = Al.get(k).numRows();
        u[k] = new DenseVector(n);
        f[k] = new DenseVector(n);
        r[k] = new DenseVector(n);
    }

    // Set up the SSOR relaxation schemes
    preM = new SSOR[m - 1];
    postM = new SSOR[m - 1];
    for (int k = 0; k < m - 1; ++k) {
        CompRowMatrix Ak = this.A[k];
        preM[k] = new SSOR(Ak, reverse, omegaPreF, omegaPreR);
        postM[k] = new SSOR(Ak, reverse, omegaPostF, omegaPostR);
        preM[k].setMatrix(Ak);
        postM[k].setMatrix(Ak);
    }
}
 

import no.uib.cipr.matrix.DenseMatrix; //导入方法依赖的package包/类
public MTJDenseDoubleMatrix2D(DenseMatrix m) {
	super(m.numRows(), m.numColumns());
	this.matrix = m;
}