Java Matrix.getAsObject方法代码示例

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public static DefaultSparseObjectMatrix fromNonZeros(Matrix nonZeros) {
	final Matrix max = nonZeros.max(Ret.NEW, Matrix.ROW);

	final long valueCount = nonZeros.getRowCount();
	final long rowCount = max.getAsLong(0, 0);
	final long columnCount = max.getAsLong(0, 1);

	DefaultSparseObjectMatrix m = new DefaultSparseObjectMatrix(rowCount, columnCount);

	for (int r = 0; r < valueCount; r++) {
		long[] c = new long[2];
		c[0] = nonZeros.getAsLong(r, 0);
		c[1] = nonZeros.getAsLong(r, 1);
		Coordinates co = Coordinates.wrap(c);
		Object val = nonZeros.getAsObject(r, 2);
		m.values.put(co, val);
	}

	return m;
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public final void calc(final Matrix source, final Matrix target) {
	if (source == target) {
		throw new RuntimeException("cannot transpose into original matrix");
	}
	if (source.isSparse() && source instanceof SparseMatrix && target.isSparse()
			&& target instanceof SparseMatrix) {
		Transpose.SPARSEMATRIX.calc((SparseMatrix) source, (SparseMatrix) target);
	} else if (source instanceof DenseDoubleMatrix2D && target instanceof DenseDoubleMatrix2D) {
		Transpose.DENSEDOUBLEMATRIX2D.calc((DenseDoubleMatrix2D) source,
				(DenseDoubleMatrix2D) target);
	} else if (source instanceof DenseMatrix2D && target instanceof DenseMatrix2D) {
		Transpose.DENSEMATRIX2D.calc((DenseMatrix2D) source, (DenseMatrix2D) target);
	} else if (source instanceof DenseMatrix && target instanceof DenseMatrix) {
		Transpose.DENSEMATRIX.calc((DenseMatrix) source, (DenseMatrix) target);
	} else {
		VerifyUtil.verify2D(source);
		VerifyUtil.verify2D(target);
		VerifyUtil.verifyEquals(source.getRowCount(), target.getColumnCount(),
				"matrices have wrong size");
		VerifyUtil.verifyEquals(source.getColumnCount(), target.getRowCount(),
				"matrices have wrong size");
		for (long[] c : source.allCoordinates()) {
			Object o = source.getAsObject(c);
			target.setAsObject(o, Coordinates.transpose(c));
		}
	}
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public static final Matrix getMatrix(Object o) {
	if (o == null) {
		return null;
	}
	if (o instanceof Matrix) {
		Matrix m = (Matrix) o;
		if (m.isScalar() && m.getAsObject(0, 0) instanceof Matrix) {
			return getMatrix(m.getAsObject(0, 0));
		} else {
			return m;
		}
	} else {
		return Matrix.Factory.linkToValue(o);
	}
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public static Object getObject(Object o) {
	if (o == null) {
		return null;
	}
	if (o instanceof Matrix) {
		Matrix m = (Matrix) o;
		if (m.getValueCount() == 1) {
			return m.getAsObject(0, 0);
		}
	}
	return o;
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public static String toString(Matrix m, Object... parameters) {
	int width = 10;
	long maxRows = UJMPSettings.getInstance().getMaxRowsToPrint();
	long maxColumns = UJMPSettings.getInstance().getMaxColumnsToPrint();

	StringBuilder s = new StringBuilder();

	final String EOL = System.getProperty("line.separator");

	long rowCount = m.getRowCount();
	long columnCount = m.getColumnCount();
	for (int row = 0; row < rowCount && row < maxRows; row++) {
		for (int col = 0; col < columnCount && col < maxColumns; col++) {
			Object o = m.getAsObject(row, col);
			String v = StringUtil.format(o);
			v = StringUtil.padLeft(v, width);
			s.append(v);
		}
		s.append(EOL);
	}

	if (rowCount == 0 || columnCount == 0) {
		s.append("[" + rowCount + "x" + columnCount + "]" + EOL);
	} else if (rowCount > UJMPSettings.getInstance().getMaxRowsToPrint()
			|| columnCount > UJMPSettings.getInstance().getMaxColumnsToPrint()) {
		s.append("[...]");
	}

	return s.toString();

}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public Object getObject(long... coordinates) {
	int i = 0;
	for (; i < positions.length; i++) {
		if (positions[i] > coordinates[getDimension()]) {
			break;
		}
	}
	i--;
	Matrix m = getSources()[i];
	long[] c = Coordinates.copyOf(coordinates);
	c[getDimension()] = c[getDimension()] - positions[i];
	return m.getAsObject(c);
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public synchronized Object getObject(long row, long column) {
	Coordinates c = Coordinates.wrap(row / tileSize[ROW], column / tileSize[COLUMN]);
	Matrix m = getMap().get(c);
	if (m == null) {
		return null;
	} else {
		return m.getAsObject(row % tileSize[ROW], column % tileSize[COLUMN]);
	}
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
private static final String getColumnType(DBType db, Matrix matrix, long column) {
	if (matrix instanceof StringMatrix) {
		return getStringType(db);
	} else if (matrix instanceof IntMatrix) {
		return getIntType(db);
	} else if (matrix instanceof LongMatrix) {
		return getLongType(db);
	} else if (matrix instanceof FloatMatrix) {
		return getFloatType(db);
	} else if (matrix instanceof DoubleMatrix) {
		return getDoubleType(db);
	} else {
		for (int r = 0; r < matrix.getRowCount(); r++) {
			Object o = matrix.getAsObject(r, column);
			if (o instanceof String) {
				return getStringType(db);
			} else if (o instanceof Integer) {
				return getIntType(db);
			} else if (o instanceof Long) {
				return getLongType(db);
			} else if (o instanceof Float) {
				return getFloatType(db);
			} else if (o instanceof Double) {
				return getDoubleType(db);
			} else if (o instanceof BigInteger) {
				return getBigIntType(db);
			} else if (o instanceof BigDecimal) {
				return getBigDecimalType(db);
			} else if (o instanceof byte[]) {
				return getByteArrayType(db);
			}
		}
	}
	return getStringType(db);
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public JackcessDenseObjectMatrix2D(File file, String tablename, Matrix matrix)
		throws IOException {
	super(matrix.getRowCount(), matrix.getColumnCount());
	try {
		database = DatabaseBuilder.create(FileFormat.V2010, file);

		TableBuilder tb = new TableBuilder(tablename);

		for (int i = 0; i < matrix.getColumnCount(); i++) {
			ColumnBuilder cb = new ColumnBuilder("Column" + i);
			switch (matrix.getValueType()) {
			case DOUBLE:
				cb.setSQLType(Types.DOUBLE);
				break;
			case INT:
				cb.setSQLType(Types.INTEGER);
				break;
			default:
				cb.setSQLType(Types.VARCHAR);
				break;
			}
			tb.addColumn(cb.toColumn());
		}

		table = tb.toTable(database);

		for (int r = 0; r < matrix.getRowCount(); r++) {
			Object[] data = new Object[(int) matrix.getColumnCount()];
			for (int c = 0; c < matrix.getColumnCount(); c++) {
				data[c] = matrix.getAsObject(r, c);
			}
			table.addRow(data);
		}
	} catch (SQLException e) {
		throw new RuntimeException(e);
	}
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public void exportToExcelFile(final Workbook workbook, final Matrix matrix, final File file, String sheetName)
		throws IOException {
	final Sheet sheet = workbook.createSheet(sheetName);

	final int rowCount = (int) matrix.getRowCount();
	final int columnCount = (int) matrix.getColumnCount();
	for (int r = 0; r < rowCount; r++) {
		Row row = sheet.createRow(r);
		for (int c = 0; c < columnCount; c++) {
			Object o = matrix.getAsObject(r, c);
			if (o != null) {
				Cell cell = row.createCell(c);
				if (o instanceof Double) {
					cell.setCellValue((Double) o);
				} else if (o instanceof String) {
					cell.setCellValue((String) o);
				} else if (o instanceof Date) {
					cell.setCellValue((Date) o);
				} else if (o instanceof Boolean) {
					cell.setCellValue((Boolean) o);
				} else {
					cell.setCellValue(StringUtil.convert(o));
				}
			}
		}
	}

	final FileOutputStream fileOutputStream = new FileOutputStream(file);
	final BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
	workbook.write(fileOutputStream);
	bufferedOutputStream.close();
	fileOutputStream.close();
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
private Object getSingleValue(PExpression expression) throws Exception {
	Matrix m = MathUtil.getMatrix(getObject(expression));
	if (m.isScalar()) {
		return m.getAsObject(0, 0);
	} else {
		return m.doubleValue();
	}
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public Object getObject(long row, long column) {
	long rows = 0;
	for (Matrix m : variable) {
		rows += m.getRowCount();
		if (rows > row) {
			long r = row - rows + m.getRowCount();
			if (column < m.getColumnCount()) {
				return m.getAsObject(r, column);
			} else {
				return 0.0;
			}
		}
	}
	return 0.0;
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
/**
 * 把矩阵导出到EXCEL文件
 * @param workbook
 * @param matrix
 * @param file
 * @param sheetName
 * @throws IOException
 */
private static void exportToExcelFile(final Workbook workbook, final Matrix matrix,
										final File file, String sheetName) throws IOException
{
	final Sheet sheet = workbook.createSheet(sheetName);
	
	final int rowCount = (int) matrix.getRowCount();
	final int columnCount = (int) matrix.getColumnCount();
	for(int r = 0; r < rowCount; r++)
	{
		Row row = sheet.createRow(r);
		for(int c = 0; c < columnCount; c++)
		{
			Object obj = matrix.getAsObject(r, c);
			if (obj != null)
			{
				Cell cell = row.createCell(c);
				if (obj instanceof Double)
				{
					cell.setCellValue((Double) obj);
				}
				else if (obj instanceof String)
				{
					cell.setCellValue((String) obj);
				}
				else if (obj instanceof Date)
				{
					cell.setCellValue((Date) obj);
				}
				else if (obj instanceof Boolean)
				{
					cell.setCellValue((Boolean) obj);
				}
				else
				{
					cell.setCellValue(StringUtil.convert(obj));
				}
			}
		}
	}

	final FileOutputStream fileOutputStream = new FileOutputStream(file);
	final BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
	workbook.write(fileOutputStream);
	
	bufferedOutputStream.close();
	fileOutputStream.close();
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
private StringBuffer formatMultiLine(Matrix m, StringBuffer toAppendTo, FieldPosition pos) {
	long maxRows = UJMPSettings.getInstance().getMaxRowsToPrint();
	long maxColumns = UJMPSettings.getInstance().getMaxColumnsToPrint();

	final String EOL = System.getProperty("line.separator");

	long rowCount = m.getRowCount();
	long columnCount = m.getColumnCount();
	long[] cursor = new long[m.getDimensionCount()];

	if (m.getDimensionCount() > 2) {
		toAppendTo.append(m.getDimensionCount());
		toAppendTo.append("D-Matrix [");
		toAppendTo.append(Coordinates.toString("x", m.getSize()));
		toAppendTo.append("]: only two dimensions are printed");
		toAppendTo.append(EOL);
	}

	if (m.getMetaData() != null) {
		format(m.getLabel(), toAppendTo, pos);
		toAppendTo.append("   ");
		for (int col = 0; col < columnCount && col < maxColumns; col++) {
			format(m.getColumnLabel(col), toAppendTo, pos);
			if (col < columnCount - 1) {
				toAppendTo.append(' ');
			}
		}
		toAppendTo.append(EOL);
		pad(toAppendTo, '=', width);
		toAppendTo.append("   ");
		for (int col = 0; col < columnCount && col < maxColumns; col++) {
			pad(toAppendTo, '-', width);
			if (col < columnCount - 1) {
				toAppendTo.append(' ');
			}
		}
		toAppendTo.append(EOL);
	}

	for (cursor[Matrix.ROW] = 0; cursor[Matrix.ROW] < rowCount && cursor[Matrix.ROW] < maxRows; cursor[Matrix.ROW]++) {
		if (m.getMetaData() != null) {
			format(m.getRowLabel(cursor[Matrix.ROW]), toAppendTo, pos);
			toAppendTo.append(" | ");
		}
		for (cursor[Matrix.COLUMN] = 0; cursor[Matrix.COLUMN] < columnCount
				&& cursor[Matrix.COLUMN] < maxColumns; cursor[Matrix.COLUMN]++) {
			Object o = m.getAsObject(cursor);
			if (o == null && m instanceof BaseBigDecimalMatrix) {
				toAppendTo = format(Double.NaN, toAppendTo, pos);
			} else if (o instanceof Matrix) {
				toAppendTo.append("[Matrix]");
			} else {
				toAppendTo = format(o, toAppendTo, pos);
			}
			if (cursor[Matrix.COLUMN] < columnCount - 1) {
				toAppendTo.append(' ');
			}
		}
		toAppendTo.append(EOL);
	}

	if (rowCount == 0 || columnCount == 0) {
		toAppendTo.append("[" + rowCount + "x" + columnCount + "]" + EOL);
	} else if (rowCount > UJMPSettings.getInstance().getMaxRowsToPrint()
			|| columnCount > UJMPSettings.getInstance().getMaxColumnsToPrint()) {
		toAppendTo.append("[...]");
	}

	return toAppendTo;
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public Object getObject(long row, long column) {
	Matrix m = columns.get(column);
	return m == null ? null : m.getAsObject(row, 0);
}