Java Matrix.ROW属性代码示例

public double getDouble(long... coordinates) {
	double factor = 0.0;
	switch (getDimension()) {
	case Matrix.COLUMN:
		factor = 1.0 - (double) coordinates[COLUMN]
				/ (double) (getSource().getColumnCount() - 1);
		break;
	case Matrix.ROW:
		factor = 1.0 - (double) coordinates[ROW] / (double) (getSource().getRowCount() - 1);
		break;
	default:
		factor = 1.0 - (double) Coordinates.product(coordinates)
				/ (double) (getSource().getRowCount() - 1);
		break;
	}
	return getSource().getAsDouble(coordinates) * factor;
}
 

public long[] next() {
	final long[] rowCoordinates = columnIterator.next();
	coordinates[Matrix.ROW] = currentRow;
	coordinates[Matrix.COLUMN] = rowCoordinates[Matrix.ROW];
	if (!columnIterator.hasNext()) {
		while (rowIterator.hasNext() && (columnIterator == null || !columnIterator.hasNext())) {
			currentRow = rowIterator.next();
			columnIterator = matrix.rows.get(currentRow).availableCoordinates().iterator();
		}
	}
	return coordinates;
}
 

public int getInt(long... coordinates) {
	if (min == null || max == null) {
		calculate();
	}
	double v = getSource().getAsDouble(coordinates);
	double mi = 0;
	double ma = 0;

	switch (getDimension()) {
	case Matrix.ROW:
		mi = min.getAsDouble(0, coordinates[COLUMN]);
		ma = max.getAsDouble(0, coordinates[COLUMN]) + UJMPSettings.getInstance().getTolerance();
		break;
	case Matrix.COLUMN:
		mi = min.getAsDouble(coordinates[ROW], 0);
		ma = max.getAsDouble(coordinates[ROW], 0) + UJMPSettings.getInstance().getTolerance();
		break;
	default:
		mi = min.getAsDouble(0, 0);
		ma = max.getAsDouble(0, 0) + UJMPSettings.getInstance().getTolerance();
		break;
	}

	double bs = (ma - mi) / numberOfBins;
	int i = (int) Math.floor((v - mi) / bs);
	return i;
}
 

public long[] next() {
	final long[] rowCoordinates = rowIterator.next();
	coordinates[Matrix.ROW] = rowCoordinates[Matrix.ROW];
	coordinates[Matrix.COLUMN] = currentColumn;
	if (!rowIterator.hasNext()) {
		while (columnIterator.hasNext() && (rowIterator == null || !rowIterator.hasNext())) {
			currentColumn = columnIterator.next();
			rowIterator = matrix.columns.get(currentColumn).availableCoordinates().iterator();
		}
	}
	return coordinates;
}
 

public Matrix createMatrix(long... size) throws Exception {
	return new EhcacheTiledObjectMatrix2D(size[Matrix.ROW], size[Matrix.COLUMN]);
}
 

public DoubleMatrix2D createMatrix(long... size) {
	return new ArrayDenseDoubleMatrix2D(size[Matrix.ROW], size[Matrix.COLUMN]);
}
 

public double getDouble(long... coordinates) {
	if (imp == null) {
		try {

			DoubleCalculation calc = null;

			switch (method) {
			case Zero:
				calc = new ImputeZero(getSource());
				break;
			case RowMean:
				calc = new ImputeMean(Matrix.ROW, getSource());
				break;
			case ColumnMean:
				calc = new ImputeMean(Matrix.COLUMN, getSource());
				break;
			case BPCA:
				calc = new ImputeBPCA(getSource());
				break;
			case KNN:
				calc = new ImputeKNN(getSource(), parameters);
				break;
			case EM:
				calc = new ImputeEM(getSource());
				break;
			case Regression:
				calc = new ImputeRegression(getSource());
				break;
			case EMimputeGene:
				calc = new ImputeLS(getSource(), method);
				break;
			case EMimputeArray:
				calc = new ImputeLS(getSource(), method);
				break;
			case LSimputeGene:
				calc = new ImputeLS(getSource(), method);
				break;
			case LSimputeArray:
				calc = new ImputeLS(getSource(), method);
				break;
			case LSimputeCombined:
				calc = new ImputeLS(getSource(), method);
				break;
			case LSimputeAdaptive:
				calc = new ImputeLS(getSource(), method);
				break;
			}

			imp = calc.calcNew();

		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	return imp.getAsDouble(coordinates);
}
 

public long[] next() {
	coordinates[Matrix.ROW] = indices[currentPos];
	currentPos++;
	return coordinates;
}
 

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;
}
 

public SparseObjectMatrix zeros(long... size) {
	return new DefaultSparseRowObjectMatrix2D(size[Matrix.ROW], size[Matrix.COLUMN]);
}
 

public SparseObjectMatrix2D zeros(long... size) {
	return new DefaultSparseRowObjectMatrix2D(size[Matrix.ROW], size[Matrix.COLUMN]);
}
 

public Matrix createMatrix(long... size) throws Exception {
	return new DefaultTiledObjectMatrix2D(size[Matrix.ROW], size[Matrix.COLUMN]);
}
 

public Matrix createMatrix(long... size) {
	return new DefaultSparseRowDoubleMatrix2D(size[Matrix.ROW], size[Matrix.COLUMN]);
}
 

public Matrix createMatrix(long... size) {
	return new ArrayDenseDoubleMatrix2D(size[Matrix.ROW], size[Matrix.COLUMN]);
}
 

public Matrix createMatrix(long... size) {
	return new DefaultSparseColumnObjectMatrix2D(size[Matrix.ROW], size[Matrix.COLUMN]);
}