灰色综合评价法 JAVA代码

做项目的时候用到的一个评估算法
灰色综合评价法

import java.math.BigDecimal;
import java.util.Arrays;

public class Grey {
    public static void main(String[] args) {
        double[][] IntData = new double[][]{
            {33.6, 66.4, 0.0},{1.6, 98.0, 0.4},
            {16.1, 82.2, 1.7},{23.5, 69.6, 6.9},
            {23.2, 65.6, 11.3},{16.9, 77.7, 5.4}};
        double[] corr = new double[IntData.length];
        double[][] GuiyiData;//归一化矩阵
        GuiyiData = normalize(IntData);
        corr = correlation(GuiyiData);
        System.out.println(Arrays.toString(corr));
    }

    public static double[] correlation(double[][] arr){
        //依据公式进行关联度的计算，返回相关程度向量corr
        double RC = 0.5;//分辨系数取0.5
        double[] temp = new double[arr[0].length];
        double[] corr = new double[arr.length];
        double[][] TwoLevelDiffArray ;//存储二级差化矩阵
        TwoLevelDiffArray = twoLevelDiff(arr);
        //计算正确，两级差化矩阵正确
        double dbTemp, dbMaxTemp;
        dbMaxTemp = RC*twoLevelMaxDiff(TwoLevelDiffArray);
        dbTemp = twoLevelMinDiff(TwoLevelDiffArray) + dbMaxTemp;
        for (int i = 1; i<arr.length; i++) {
            //参考序列不在计算范围，因此需要从1开始
            for (int j = 0; j<arr[i].length; j++) {
                temp[j] = (dbTemp/(Abs(arr[0][j] - arr[i][j])+dbMaxTemp));
            }
            corr[i] = sumValue(temp)/arr[i].length;//归一化，并求均值
            BigDecimal b = new BigDecimal(corr[i]);
            corr[i] = b.setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue();
        }
        return corr;
    }
    public static double[][] normalize(double[][] array){
        //矩阵的标准化
        double[][] TempData = new double[array.length][array[0].length];
        for (int i = 0; i<array.length; i++)
        {
            for (int j = 0; j<array[i].length;j++)
            { //标准化之后的矩阵
                TempData[i][j] = array[i][j] / (sumValue(array[i]) / array[i].length);
            }
        }
        return TempData;
    }
    public static double[][] twoLevelDiff(double[][] arr){//二级差异化矩阵计算
        double[][] TwoLevelDiffArray = new double[arr.length][arr[0].length];//存储二级差化矩阵
        for (int i = 1; i<arr.length; i++) {
            for (int j = 0; j<arr[i].length; j++) {
                TwoLevelDiffArray[i][j] = Abs(arr[0][j]-arr[i][j]);
            }
        }
        return TwoLevelDiffArray;//返回二级差化矩阵
    }
    public static double Abs(double t){
        return t >= 0 ? t : -t;
    }
    public static double sumValue(double[] arr){//取数组和
        double sum = 0;
        for (int i=0; i < arr.length;i++) {sum += arr[i];}
        return sum;
    }
    public static double twoLevelMinDiff(double[][] arr){
        //求解矩阵的两级最小差
        return minArrayValue(arr);
    }
    public static double twoLevelMaxDiff(double[][] arr){
        //求解矩阵的两级最大差
        return maxArrayValue(arr);
    }
    public static double minArrayValue(double[][] arr){
        double Value ;//计算矩阵的两级差的最小值
        double[] Temp = new double[arr.length];
        for (int i = 0; i<arr.length; i++) {
            Temp[i] = getMin(arr[i]);
        }
        Value = getMin(Temp);
        return Value;
    }
    public static double maxArrayValue(double[][] arr){
        double Value ;//计算矩阵的两级差的最大值（先求行最大，再求列最大）
        double[] Temp = new double[arr.length];
        for (int i = 0; i<arr.length; i++) {
            Temp[i] = getMax(arr[i]);
        }
        Value = getMax(Temp);
        return Value;
    }
    public static double getMax(double[] arr){
        double max = arr[0];//取数组最大值
        for (int i=0; i < arr.length;i++)
        {
            if (arr[i]>max){
                max = arr[i];
            }
        }
        return max;
    }
    public static double getMin(double[] arr){
        double min = arr[0];// 取最小值
        for (int i=0; i < arr.length;i++)
        {
            if (arr[i]<min){
                min  = arr[i];
            }
        }
        return min;
    }
}