MinMaxNormalize 规一化算法

public class MinMaxNormalize {

	/**
	 * 线性归一化 公式：X(norm) = (X - min) / (max - min)
	 *
	 * @param points     原始数据
	 * @param conversion 是否行转列
	 * @return 归一化后的数据
	 */
	public static double[] normalize(double[][] points, boolean conversion) {
		if (points == null || points.length < 1) {
			return new double[0];
		}
		//新数组
		double[][] newPoints = new double[points[0].length][points.length];
		if (conversion) {
			for (int i = 0; i < points.length; i++) {
				for (int j = 0; j < points[i].length; j++) {
					newPoints[j][i] = points[i][j];
				}
			}
		} else {
			newPoints = points;
		}

		Arrays.stream(newPoints).forEach(val -> {
			log.info("newPoints val:{}", val);
		});

		double[][] p = new double[newPoints.length][newPoints[0].length];
		for (int j = 0; j < newPoints[0].length; j++) {
			for (int i = 0; i < newPoints.length; i++) {
				p[i] = minMax(newPoints[i]);
			}
		}

		Arrays.stream(p).forEach(val -> {
			log.info("p val:{}", val);
		});
		double[] sumArry = Arrays.stream(p).mapToDouble(val -> Arrays.stream(val).sum()).toArray();
		double[] norArry = proportion(sumArry);
		log.info("norArry:{}", norArry);
		return norArry;
	}

	private static double[] minMax(double[] points) {
		double[] p = new double[points.length];
		double maxV = maxV(points);
		double minV = minV(points);
		for (int i = 0; i < points.length; i++) {
			p[i] = maxV == minV ? minV : (points[i] - minV) / (maxV - minV);
		}
		return p;
	}

	private static double[] proportion(double[] points) {
		double[] p = new double[points.length];
		double sumNum = Arrays.stream(points).sum();
		log.info("sumNum:{}", sumNum);
		for (int i = 0; i < points.length; i++) {
			p[i] = NumberUtil.round(points[i] / sumNum, 3).doubleValue();
		}
		return p;
	}


	/**
	 * 获取矩阵的某一列
	 *
	 * @param points points
	 * @param column column
	 * @return double[]
	 */
	public static double[] getMatrixCol(double[][] points, int column) {
		double[] matrixJ = new double[points.length];
		for (int i = 0; i < points.length; i++) {
			matrixJ[i] = points[i][column];
		}
		return matrixJ;
	}

	/**
	 * 获取数组中的最小值
	 *
	 * @param matrixJ matrixJ
	 * @return v
	 */
	public static double minV(double[] matrixJ) {
		return Arrays.stream(matrixJ).min().getAsDouble();
	}

	/**
	 * 获取数组中的最大值
	 *
	 * @param matrixJ matrixJ
	 * @return v
	 */
	public static double maxV(double[] matrixJ) {
		return Arrays.stream(matrixJ).max().getAsDouble();
	}

}