矩阵（二维数组）标准化

• Min-Max标准化
• Z-Score标准化
• 均值标准化

package com.standardized;

import Jama.Matrix;

public class Standardized {
    
    //计算最小值
    public double[] getMin(double[][] array){
        int h = array.length; //行号 -- h
        int l = array[0].length; //列号 -- l
        //用来存储每列指标的最小值
        double[] minResult = new double[l];
        for (int i = 0; i < l; i++){ //第几列的数据
            double min = array[0][0];
            //这个for循环结束后，这一列数据的最小值被取出
            for (int j = 0; j < h; j++){ //第几行的数据
                if (min > array[j][i]){
                    min = array[j][i];
                }
            }
            minResult[i] = min;
        }
        return minResult;
    }

    //计算最大值
    public double[] getMax(double[][] array){
        int h = array.length; //行号 -- h
        int l = array[0].length; //列号 -- l
        //用来存储每列指标的最小值
        double[] maxResult = new double[l];
        for (int i = 0; i < l; i++){ //第几列的数据
            double max = 0;
            //这个for循环结束后，这一列数据的最小值被取出
            for (int j = 0; j < h; j++){ //第几行的数据
                if (max < array[j][i]){
                    max = array[j][i];
                }
            }
            maxResult[i] = max;
        }
        return maxResult;
    }

    //求平均值
    public double[] getAverage(double[][] array) {
        int h = array.length; // 行号--h
        int l = array[0].length;// 列号--l
        double[] average = new double[l];// 每个变量的均值
        for (int i = 0; i < l; i++) {
            double temp = 0.0;
            for (int j = 0; j < h; j++) {
                temp += array[j][i];
            }
            average[i] = temp / h;
        }
        return average;
    }

    // 计算方差
    public double[] getVariance(double[][] array) {
        int h = array.length; // 行号--h
        int l = array[0].length;// 列号--l
        double[] average = getAverage(array);
        double[] var = new double[l];

        for (int i = 0; i < l; i++) {
            double temp = 0.0;
            for (int j = 0; j < h; j++) {
                temp += Math.pow((array[j][i] - average[i]), 2);
            }
            var[i] = temp / (h - 1);
        }
        return var;
    }

    // 计算标准差
    public double[] getStandardDevition(double[] var) {
        double[] sd = new double[var.length];
        for (int i = 0; i < var.length; i++) {
            sd[i] = Math.sqrt(var[i]);
        }
        return sd;
    }

    // Z-Score标准化
    public double[][] getStandard(double[][] array, double[] sd) {
        int h = array.length; // 行号--h
        int l = array[0].length;// 列号--l
        double[][] result = new double[h][l];// 标准化
        double[] average = getAverage(array);

        //使用Z-Score进行数据标准化
        for (int i = 0; i < h; i++) {
            for (int j = 0; j < l; j++) {
                result[i][j] = (array[i][j] - average[j]) / sd[j];
            }
        }
        return result;
    }

    //Min_Max标准化
    public double[][] MinMax(double[][] array, double[] min, double[] max){
        int h = array.length; //行数
        int l = array[0].length; //列数

        //用来存储标准化后的数据
        double[][] minmaxResoult = new double[h][l];
        double num;
        for (int i = 0; i < l; i++){ //列
            for (int j = 0; j < h; j++){ //行
                num = (array[j][i] - min[i]) / (max[i] - min[i]);
                minmaxResoult[j][i] = num;
            }
        }
        return minmaxResoult;
    }

    //到参考点的距离
    public double[][] distMean(double[][] array, double[] avg){
        int h = array.length; //行数
        int l = array[0].length; //列数

        double num;
        double[][] distmeanResoult = new double[h][l];

        for (int i = 0; i < l; i++){ //列数
            for (int j = 0; j < h; j++){ //行数
                num = (array[j][i] - avg[i]) / avg[i];
                distmeanResoult[j][i] = num;
            }
        }
        return distmeanResoult;
    }
}

测试类中使用了 Jama 的依赖，现在给出所使用的maven依赖：

	gov.nist.math
    jama
    1.0.3

测试类的编写：

package Standardized;

import Jama.Matrix;
import com.standardized.Standardized;
import org.junit.Test;

public class testStandardized {

    //初始数据的准备
    public double[][] rawdata = {
            {187,125.6,200.2,50.7,3.08,4.15,10,27.4},
            {289,130,179.1,66.2,3,4.07,12,13.9},
            {271,156.6,125.8,59.7,3.1,4.14,11.4,15.3},
            {994,64.6,49,80.8,3,3.86,9.5,10},
            {779,9.8,4.8,66.7,2.97,3.65,10.8,23.2},
            {189,151.2,136,50.9,3.02,3.77,9.4,9.5},
            {82,134,57.4,61.9,3.02,3.73,9.4,14.9},
            {31,38.6,108,48.7,2.94,4.18,11.6,14.2},
            {75,18.2,125.9,16.2,2.94,3.94,10.9,25.3},
            {8,25.5,72.3,74.9,2.95,3.83,7.1,24.2},
            {235,36.8,41.2,64.2,2.94,3.75,10.2,14.4},
            {103,20.2,193.6,19,3.12,4.39,11.9,11.2},
            {106,110.3,48.6,53.6,2.97,3.68,9.4,12.3},
            {72,73.9,58.9,47.6,2.91,3.86,9.3,13.6},
            {103,13,146.7,15.4,2.86,3.91,11.7,13.1},
            {165,14.8,84.2,50.3,2.99,3.79,8.4,13.6},
            {205,33.6,36.4,58.9,2.97,3.8,7.9,12.6},
            {74,43.6,43.2,45,2.96,3.74,9.6,11},
            {42,8.6,21,53.4,2.86,3.62,7.3,15.6},
            {13,9.8,30.4,51,3,3.65,7.2,13},
            {28,4.2,25,51.7,2.75,3.68,9.5,8.2},
            {26,6.2,21.6,63.5,2.73,3.46,9.1,7.7},
            {105,4,20.3,49.5,2.84,3.71,7.1,10.6},
    };

    Standardized std = new Standardized();

    @Test
    public void testMin(){
        double[] stdMin = std.getMin(rawdata);
        for (double v : stdMin) {
            System.out.print(v + " ");
        }
    }

    @Test
    public void testMax(){
        double[] stdMin = std.getMax(rawdata);
        for (double v : stdMin) {
            System.out.print(v + " ");
        }
    }

    @Test
    public void testMinMax(){
        double[] max = std.getMax(rawdata);
        double[] min = std.getMin(rawdata);
        double[][] standResoult = std.MinMax(rawdata, min, max);

        Matrix matrix = new Matrix(standResoult);
        //使用矩阵类进行数据的打印
        //第一个参数设置矩阵距离，第二个参数设置数据保留的位数
        matrix.print(6,4);
    }

    @Test
    public void testStandard(){
        double[] variance = std.getVariance(rawdata);
        double[] standardDevition = std.getStandardDevition(variance);
        double[][] standard = std.getStandard(rawdata, standardDevition);

        Matrix matrix = new Matrix(standard);
        matrix.print(6,4);
    }

    @Test
    public void testDistMean(){
        double[] average = std.getAverage(rawdata);
        double[][] doubles = std.distMean(rawdata, average);

        Matrix matrix = new Matrix(doubles);
        matrix.print(6,4);
    }
}