Java Matrix.getAsDouble方法代码示例

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
/**
 * 用于计算一个矩阵的元素中，绝对值最大的那个值。
 *
 * @param matrix
 * @return
 */
public static double AbsMax(Matrix matrix) {
    double maxValue = 0.0;
    long[] matrix_size = matrix.getSize();
    long m = matrix_size[0];
    long n = matrix_size[1];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            double absValue = matrix.getAsDouble(i, j);
            if (absValue < 0.0)
                absValue = absValue * (-1);
            if (absValue > maxValue)
                maxValue = absValue;
        }
    }
    return maxValue;
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
/**
 * 用于把矩阵按行归一化
 *
 * @param oriMatrix
 * @return
 */
public static Matrix NormByRow(Matrix oriMatrix) {
    long[] size = oriMatrix.getSize();
    long m = size[0];
    long n = size[1];
    Matrix normedMatrix = Matrix.Factory.zeros(m, n);
    for (int i = 0; i < m; i++) {
        double summary = 0.0;
        for (int j = 0; j < n; j++) {
            summary = summary + oriMatrix.getAsDouble(i, j);
        }
        if (summary == 0)
            continue;
        else {
            for (int j = 0; j < n; j++) {
                normedMatrix.setAsDouble(oriMatrix.getAsDouble(i, j) / summary, i, j);
            }
        }
    }
    return normedMatrix;
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public static double f1MeasureMicro(Matrix confusionMatrix) {
	double tp = 0;
	double fn = 0;
	double fp = 0;
	for (int catIndex = 0; catIndex < confusionMatrix.getRowCount(); catIndex++) {
		tp += confusionMatrix.getAsDouble(catIndex, catIndex);
		for (int r = 0; r < confusionMatrix.getRowCount(); r++) {
			if (r == catIndex) {
				continue;
			}
			fn += confusionMatrix.getAsDouble(r, catIndex);
		}
		for (int c = 0; c < confusionMatrix.getRowCount(); c++) {
			if (c == catIndex) {
				continue;
			}
			fp += confusionMatrix.getAsDouble(catIndex, c);
		}
	}
	return f1Measure(tp, fp, fn);
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public double getDouble(long... coordinates) {
	Matrix m1 = getSource().selectRows(Ret.LINK, coordinates[ROW]);
	Matrix m2 = getSource().selectRows(Ret.LINK, coordinates[COLUMN]);
	double aiSum = 0;
	double a2Sum = 0;
	double b2Sum = 0;
	for (long i = 0; i < m1.getColumnCount(); i++) {
		double a = m1.getAsDouble(0, i);
		double b = m2.getAsDouble(0, i);
		if (ignoreNaN) {
			if (!MathUtil.isNaNOrInfinite(a) && !MathUtil.isNaNOrInfinite(b)) {
				aiSum += a * b;
				a2Sum += a * a;
				b2Sum += b * b;
			}
		} else {
			aiSum += a * b;
			a2Sum += a * a;
			b2Sum += b * b;
		}
	}
	return aiSum / (Math.sqrt(a2Sum) * Math.sqrt(b2Sum));
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public static double getCosineSimilartiy(Matrix m1, Matrix m2, boolean ignoreNaN) {
	VerifyUtil.verifySameSize(m1, m2);
	double aiSum = 0;
	double a2Sum = 0;
	double b2Sum = 0;
	for (long[] c : m1.allCoordinates()) {
		double a = m1.getAsDouble(c);
		double b = m2.getAsDouble(c);
		if (ignoreNaN) {
			if (!MathUtil.isNaNOrInfinite(a) && !MathUtil.isNaNOrInfinite(b)) {
				aiSum += a * b;
				a2Sum += a * a;
				b2Sum += b * b;
			}
		} else {
			aiSum += a * b;
			a2Sum += a * a;
			b2Sum += b * b;
		}
	}
	return aiSum / (Math.sqrt(a2Sum) * Math.sqrt(b2Sum));
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public double getDouble(long... coordinates) {
	if (pinv == null) {

		Matrix[] usv = getSource().svd();
		Matrix u = usv[0];
		Matrix s = usv[1];
		Matrix v = usv[2];

		for (int i = (int) Math.min(s.getRowCount(), s.getColumnCount()); --i >= 0;) {
			double d = s.getAsDouble(i, i);
			if (Math.abs(d) > UJMPSettings.getInstance().getTolerance()) {
				s.setAsDouble(1.0 / d, i, i);
			} else {
				s.setAsDouble(0.0, i, i);
			}
		}

		pinv = v.mtimes(s.transpose()).mtimes(u.transpose());

	}
	return pinv.getAsDouble(coordinates);
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public double getDouble(long... coordinates) {
	final Matrix m1 = getSources()[0];
	final Matrix m2 = getSources()[1];

	final long row = coordinates[ROW];
	final long col = coordinates[COLUMN];

	double sum = 0.0;
	if (ignoreNaN) {
		for (long k = m1.getColumnCount(); --k >= 0;) {
			sum += MathUtil.ignoreNaN(m1.getAsDouble(row, k))
					* MathUtil.ignoreNaN(m2.getAsDouble(k, col));
		}
	} else {
		for (long k = m1.getColumnCount(); --k >= 0;) {
			sum += m1.getAsDouble(row, k) * m2.getAsDouble(k, col);
		}
	}

	return sum;
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public static double SumMatrix(Matrix matrix) {
    double value = 0.0;
    long[] matrix_size = matrix.getSize();
    long m = matrix_size[0];
    long n = matrix_size[1];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            value = value + matrix.getAsDouble(i, j);
        }
    }
    return value;
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
/**
 * 用于找到一个行矩阵的最大值出现在的位置。
 *
 * @param matrix：这需要是一个行矩阵。一行，n列。
 * @return
 */
public static long MaxLocation(Matrix matrix) {
    long l = 0;
    double maxValue = AbsMax(matrix);
    long[] matrix_size = matrix.getSize();
    long n = matrix_size[1];
    for (int i = 0; i < n; i++) {
        if (matrix.getAsDouble(0, i) == maxValue) {
            l = i;
            break;
        }
    }
    return l;
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
/**
 * @return
 */
public double[] getVector() {
	double[] v = null;
	if(matrix instanceof Matrix) {
		Matrix m = (Matrix) matrix;
		v = new double[(int) m.getSize()[0]];
		for(int i=0; i<v.length; i++)
			v[i] = m.getAsDouble(i);
	}
	return v;
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public static final void toWriter(Writer w, Matrix m, Object... parameters) throws IOException {
	w.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
	w.write("<graphml>\n");
	w.write("<key id=\"k0\" for=\"node\" attr.name=\"variableName\" attr.type=\"string\"></key>\n");
	w.write("<key id=\"k1\" for=\"node\" attr.name=\"description\" attr.type=\"string\"></key>\n");
	w.write("<key id=\"k2\" for=\"edge\" attr.name=\"confidence\" attr.type=\"double\"><default>0.0</default></key>\n");
	w.write("<key id=\"k3\" for=\"edge\" attr.name=\"directed\" attr.type=\"boolean\"><default>false</default></key>\n");
	w.write("<key id=\"k5\" for=\"node\" attr.name=\"xPos\" attr.type=\"string\"></key>\n");
	w.write("<key id=\"k6\" for=\"node\" attr.name=\"yPos\" attr.type=\"string\"></key>\n");

	w.write("<graph id=\"" + m.getLabel() + "\" edgedefault=\"undirected\">\n");

	for (int i = 0; i < m.getRowCount(); i++) {
		w.write("<node id=\"node" + i + "\">\n");
		w.write("<data key=\"k0\">" + m.getRowLabel(i).replaceAll("[<>&]", "") + "</data>\n");
		// w.write("<data key=\"k5\">" + n.getPosX() + "</data>\n");
		// w.write("<data key=\"k6\">" + n.getPosY() + "</data>\n");
		w.write("</node>\n");
	}

	int id = 0;
	for (long[] c : m.allCoordinates()) {
		if (m.getAsDouble(c) > 0.0) {
			w.write("<edge id=\"edge" + (id++) + "\" ");
			w.write("source=\"node" + c[Matrix.ROW] + "\" ");
			w.write("target=\"node" + c[Matrix.COLUMN] + "\">\n");
			w.write("</edge>\n");
		}
	}
	w.write("</graph>\n");
	w.write("</graphml>");
	w.close();
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public Matrix predictOne(Matrix input) {
	input = input.toColumnVector(Ret.LINK);
	final double[] probs = new double[classCount];
	final double[] logs = new double[classCount];

	for (int j = 0; j < classCount; j++) {
		logs[j] += Math.log(classDists[j].getProbability(1.0));
	}

	// for all features
	for (int j = 0; j < input.getColumnCount(); j++) {
		// for all classes
		double probSum = 0;
		for (int i = 0; i < classCount; i++) {
			double value = input.getAsDouble(0, j);
			double probability = dists[j][i].getProbability(value);
			probs[i] = probability;
			probSum += probability;
		}
		for (int i = 0; i < classCount; i++) {
			logs[i] += Math.log(probs[i] / probSum);
		}
	}

	final double[] finalProbs = MathUtil.logToProbs(logs);
	Matrix m = Matrix.Factory.linkToArray(finalProbs).transpose();
	return m;
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public static double precisionMicro(Matrix confusionMatrix) {
	double tp = 0;
	double fp = 0;
	for (int catIndex = 0; catIndex < confusionMatrix.getRowCount(); catIndex++) {
		tp += confusionMatrix.getAsDouble(catIndex, catIndex);
		for (int c = 0; c < confusionMatrix.getRowCount(); c++) {
			if (c == catIndex) {
				continue;
			}
			fp += confusionMatrix.getAsDouble(catIndex, c);
		}
	}
	return precision(tp, fp);
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public static double calc(Matrix m) {
	double sum = 0.0;
	for (long[] c : m.availableCoordinates()) {
		sum += m.getAsDouble(c);
	}
	return sum / Coordinates.product(m.getSize());
}
 

import org.ujmp.core.Matrix; //导入方法依赖的package包/类
public static double calc(Matrix m) {
	double min = Double.MAX_VALUE;
	double v = 0.0;
	for (long[] c : m.availableCoordinates()) {
		min = (v = m.getAsDouble(c)) < min ? v : min;
	}
	min = min == Double.MAX_VALUE ? Double.NaN : min;
	return min;
}