Java Matrix.getColumnCount方法代码示例

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
@Test
public void testSquareArbitrariness() {
	Matrix a = Matrix.Factory.zeros(3, 3); // example from ucla.edu
	a.setAsDouble(4, 0, 0);
	a.setAsDouble(2, 0, 1);
	a.setAsDouble(2, 0, 2);
	a.setAsDouble(4, 1, 0);
	a.setAsDouble(6, 1, 1);
	a.setAsDouble(8, 1, 2);
	a.setAsDouble(-2, 2, 0);
	a.setAsDouble(2, 2, 1);
	a.setAsDouble(4, 2, 2);
	Matrix a12 = a.ginv();
	Matrix ima12a = Ginv.arbitrariness(a, a12);
	for (int row = 0; row < ima12a.getRowCount(); ++row) {
		for (int col = 0; col < ima12a.getColumnCount(); ++col) {
			assertEquals(0.0, ima12a.getAsDouble(row, col), 0.001);
		}
	}
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public final static void compareAnnotation(Matrix m) {
	for (int r = 0; r < m.getRowCount(); r++) {
		if (r == 0) {
			assertEquals(null, m.getRowLabel(r));
		} else {
			assertEquals("row" + r, m.getRowLabel(r));
		}
	}

	for (int c = 0; c < m.getColumnCount(); c++) {
		if (c == 1) {
			assertEquals(null, m.getColumnLabel(c));
		} else {
			assertEquals("col" + c, m.getColumnLabel(c));
		}
	}

	assertEquals("label", m.getLabel());
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
@Test
public final void testQRFatSmall() throws Exception {
	Matrix a = createMatrixWithAnnotation(4, 6);

	if (!isSupported(a, MatrixLibraries.QR, MatrixLayout.FAT, Size.SMALL, null)) {
		return;
	}

	for (int r = 0, v = 1; r < a.getRowCount(); r++) {
		for (int c = 0; c < a.getColumnCount(); c++) {
			a.setAsDouble(v++, r, c);
		}
	}
	Matrix[] qr = a.qr();
	Matrix prod = qr[0].mtimes(qr[1]);

	assertEquals(0.0, prod.minus(a).getRMS(), TOLERANCE);

	if (a instanceof Erasable) {
		((Erasable) a).erase();
	}
	if (prod instanceof Erasable) {
		((Erasable) prod).erase();
	}
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
@Test
public final void testSVDFatSmall() throws Exception {
	Matrix a = createMatrixWithAnnotation(4, 6);

	if (!isSupported(a, MatrixLibraries.SVD, MatrixLayout.FAT, Size.SMALL, null)) {
		return;
	}

	for (int r = 0, v = 1; r < a.getRowCount(); r++) {
		for (int c = 0; c < a.getColumnCount(); c++) {
			a.setAsDouble(v++, r, c);
		}
	}

	Matrix[] svd = a.svd();

	Matrix prod = svd[0].mtimes(svd[1]).mtimes(svd[2].transpose());

	assertEquals(0.0, prod.minus(a).getRMS(), TOLERANCE);

	if (a instanceof Erasable) {
		((Erasable) a).erase();
	}
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
@Test
public void testPlusScalar() {
	Matrix matrix1 = Matrix.Factory.zeros(M2ROWS, M2ROWS);
	for (int i = 0; i < M2ROWS; i++) {
		matrix1.setAsDouble(1, i, i);
	}
	Matrix result = matrix1.plus(PRODUCT);
	for (int row = 0; row < result.getRowCount(); ++row) {
		for (int col = 0; col < result.getColumnCount(); ++col) {
			if (row == col) {
				assertEquals(1 + PRODUCT, result.getAsDouble(row, col), 0.001);
			} else {
				assertEquals(PRODUCT, result.getAsDouble(row, col), 0.001);
			}
		}
	}
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
private static Collection<?> getProductsInLine(Matrix data, long row) {
	Set<Object> products = new HashSet<Object>();
	for (int c = 1; c < data.getColumnCount(); c++) {
		String prod = data.getAsString(row, c);
		if (prod != null) {
			prod = prod.trim().intern();
			if (prod.length() != 0) {
				products.add(prod);
			}
		}
	}
	return products;
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public Matrix mtimes(Matrix m) {
	if (m instanceof ParallelColtDenseDoubleMatrix2D) {
		cern.colt.matrix.tdouble.impl.DenseDoubleMatrix2D ret = new cern.colt.matrix.tdouble.impl.DenseDoubleMatrix2D(
				(int) getRowCount(), (int) m.getColumnCount());
		matrix.zMult(((ParallelColtDenseDoubleMatrix2D) m).matrix, ret);
		Matrix result = new ParallelColtDenseDoubleMatrix2D(ret);
		MapMatrix<String, Object> a = getMetaData();
		if (a != null) {
			result.setMetaData(a.clone());
		}
		return result;
	} else {
		return super.mtimes(m);
	}
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public DefaultDenseGenericMatrix2D(Matrix m) {
	super(m.getRowCount(), m.getColumnCount());
	values = new Object[(int) m.getRowCount()][(int) m.getColumnCount()];
	for (long[] c : m.allCoordinates()) {
		setAsObject(m.getAsObject(c), c);
	}
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public Map<String, Object> calculateObjects(Map<String, Object> input) {
	Map<String, Object> result = new HashMap<String, Object>();

	Matrix source = MathUtil.getMatrix(input.get(SOURCE));

	Matrix target = Matrix.Factory.zeros(source.getRowCount(), 1);

	long cols = source.getColumnCount();
	long rows = source.getRowCount();
	for (int k = 0; k < rows; k++) {
		int tp = 0;
		int fn = 0;
		for (int r = 0; r < rows; r++) {
			for (int c = 0; c < cols; c++) {
				int count = source.getAsInt(r, c);
				boolean expected = r == k;
				boolean predicted = c == k;
				if (expected && predicted) {
					tp += count;
				} else if (expected && (!predicted)) {
					fn += count;
				}
			}
		}
		target.setAsDouble(MathUtil.sensitivity(tp, fn), k, 0);
	}
	result.put(TARGET, target);
	return result;
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public final Matrix[] calc(Matrix source) {
	if (UJMPSettings.getInstance().getNumberOfThreads() == 1) {
		if (source.getRowCount() >= THRESHOLD && source.getColumnCount() >= THRESHOLD) {
			return MATRIXLARGESINGLETHREADED.calc(source);
		} else {
			return MATRIXSMALLSINGLETHREADED.calc(source);
		}
	} else {
		if (source.getRowCount() >= THRESHOLD && source.getColumnCount() >= THRESHOLD) {
			return MATRIXLARGEMULTITHREADED.calc(source);
		} else {
			return MATRIXSMALLMULTITHREADED.calc(source);
		}
	}
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public JScienceDenseDoubleMatrix2D(Matrix matrix) {
	super(matrix.getRowCount(), matrix.getColumnCount());
	this.matrix = Float64Matrix.valueOf(matrix.toDoubleArray());
	if (matrix.getMetaData() != null) {
		setMetaData(matrix.getMetaData().clone());
	}
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
private void createMatrix() {
	Matrix source = getSource();
	Matrix m = Matrix.Factory.zeros(source.getSize());
	for (long c = 0; c < source.getColumnCount(); c++) {
		double prod = 1;
		for (long r = 0; r < source.getRowCount(); r++) {
			double v = source.getAsDouble(r, c);
			if (ignoreNaN || !MathUtil.isNaNOrInfinite(v)) {
				prod *= v;
			}
			m.setAsDouble(prod, r, c);
		}
	}
	cumprod = m;
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public ValueToColumn(Matrix matrix) {
	super(matrix);
	if (matrix.getColumnCount() != 1) {
		throw new RuntimeException("matrix must have one column");
	}
	for (long[] c : getSource().availableCoordinates()) {
		max = Math.max(max, getSource().getAsInt(c));
	}
	this.size = new long[] { getSource().getRowCount(), max + 1 };
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
/**
 * Solve A*X = B
 * 
 * @param B
 *            A Matrix with as many rows as A and any number of columns.
 * @return X so that L*L'*X = B
 * @exception IllegalArgumentException
 *                Matrix row dimensions must agree.
 * @exception RuntimeException
 *                Matrix is not symmetric positive definite.
 */

public final DenseDoubleMatrix2D solve(Matrix B) {
	if (B.getRowCount() != n) {
		throw new IllegalArgumentException("Matrix row dimensions must agree.");
	}
	if (!isspd) {
		throw new RuntimeException("Matrix is not symmetric positive definite.");
	}

	// Copy right hand side.
	final double[][] X = B.toDoubleArray();
	final int nx = (int) B.getColumnCount();

	// Solve L*Y = B;
	for (int k = 0; k < n; k++) {
		for (int j = 0; j < nx; j++) {
			for (int i = 0; i < k; i++) {
				X[k][j] -= X[i][j] * L[k][i];
			}
			X[k][j] /= L[k][k];
		}
	}

	// Solve L'*X = Y;
	for (int k = n - 1; k >= 0; k--) {
		for (int j = 0; j < nx; j++) {
			for (int i = k + 1; i < n; i++) {
				X[k][j] -= X[i][j] * L[i][k];
			}
			X[k][j] /= L[k][k];
		}
	}

	return Matrix.Factory.linkToArray(X);
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
@Test
public void testNonSquareInverse() {
	Matrix a = Matrix.Factory.zeros(3, 4);
	a.setAsDouble(4, 0, 0);
	a.setAsDouble(2, 0, 1);
	a.setAsDouble(2, 0, 2);
	a.setAsDouble(2, 0, 3);
	a.setAsDouble(4, 1, 0);
	a.setAsDouble(6, 1, 1);
	a.setAsDouble(8, 1, 2);
	a.setAsDouble(8, 1, 3);
	a.setAsDouble(-2, 2, 0);
	a.setAsDouble(2, 2, 1);
	a.setAsDouble(4, 2, 2);
	a.setAsDouble(4, 2, 3);
	Matrix a12 = a.ginv();
	Matrix ima12a = Ginv.arbitrariness(a, a12);
	for (int row = 0; row < ima12a.getRowCount(); ++row) {
		for (int col = 0; col < ima12a.getColumnCount(); ++col) {
			if (col == 3 && (row == 2 || row == 3)) {
				if (row == 2) {
					assertEquals(-1.0, ima12a.getAsDouble(row, col), 0.001);
				}
				if (row == 3) {
					assertEquals(1.0, ima12a.getAsDouble(row, col), 0.001);
				}
			} else {
				assertEquals(0.0, ima12a.getAsDouble(row, col), 0.001);
			}
		}
	}
}