根据矩阵和阶数计算最大特征值和特征向量

素颜马尾好姑娘i 2022-08-31 06:54 142阅读 0赞

1.看到这个标题是不是在想，这个怎么算的呀，忘记的自行百度学习一下吧

2.首先加入maven 依赖

<dependency>
                <groupId>gov.nist.math</groupId>
                <artifactId>jama</artifactId>
                <version>1.0.3</version>
            </dependency>

2.使用方法

1.代码片段

@Data
    @ApiModel(value="matrixParam")
    public class MatrixParam {
        @ApiModelProperty(value = "矩阵的列组合数据")
        private String[] columnwise;
        @ApiModelProperty(value = "要素ids,多个用'/'分割")
        private String ids;
        @ApiModelProperty(value = "名称")
        private List<String> name;
    }

2.核心代码段

/**
         * 根据矩阵和阶数计算最大特征值和特征向量
         *
         * @param matrixParam
         * @return
         */
        public MatrixBO matrixCal(MatrixParam matrixParam) {
            log.info("矩阵计算-->{}",matrixParam);
            DecimalFormat df = new DecimalFormat("#.0000");
            EcaAhp ahp = new EcaAhp();
            MatrixBO dto = new MatrixBO();
            int length = matrixParam.getColumnwise().length;
            int number = (int) Math.sqrt(length);
            ahp.setIds(matrixParam.getIds());
            ahp.setMatrix(JSONUtil.toJsonStr(matrixParam.getColumnwise()));
            ahp.setNumber(number);
            //矩阵数组转换
            String[] columnwise = matrixParam.getColumnwise();
            double[] mp = new double[length];
            for (int i = 0; i < columnwise.length; i++) {
                if (columnwise[i].contains("/")) {
                    String[] split = columnwise[i].split("/");
                    mp[i] = Double.parseDouble(split[0]) / Double.parseDouble(split[1]);
                } else {
                    mp[i] = Double.parseDouble(columnwise[i]);
                }
            }
            Matrix A = new Matrix(mp, number);//构造矩阵
            EigenvalueDecomposition Eig = A.eig();
            Matrix D = Eig.getD();
            Matrix V = Eig.getV();
            double a = 0d;
            int n = 0;
            for (int i = 0; i < D.getRowDimension(); i++) {
                for (int j = 0; j < D.getColumnDimension(); j++) {
                    if (a < D.get(i, j)) {
                        a = D.get(i, j);
                        n = j;
                    }
                }
            }
            List<BigDecimal> list = new ArrayList<>();
            for (int j = 0; j < V.getRowDimension(); j++) {
                list.add(new BigDecimal(df.format(V.get(j, n))));
            }
            ahp.setMaxEigenvalue(Double.parseDouble(df.format(a)));
            ahp.setMaxEigenvector(JSONUtil.toJsonStr(list));
            //归一
            List<BigDecimal> weight = groupNormalization(list);
            ahp.setWeight(JSONUtil.toJsonStr(weight));
            //计算cr值
            BigDecimal cr = calCR(ahp);
            ahp.setCr(cr);
            //组装权重数据
            String[] ids = matrixParam.getIds().split("/");
            JSONArray jsonArray = JSONUtil.parseArray(ahp.getWeight());
            List<MatrixBO.GlobalNormalization> res = new ArrayList<>();
            for (int i = 0; i < ids.length; i++) {
                MatrixBO.GlobalNormalization globalNormalization = new MatrixBO.GlobalNormalization();
                globalNormalization.setId(ids[i]);
                globalNormalization.setName(matrixParam.getName().get(i));
                globalNormalization.setWeight(String.valueOf(jsonArray.get(i)));
                globalNormalization.setCr(ahp.getCr());
                res.add(globalNormalization);
            }
            dto.setList(res);
            //保存或修改计算结果
            List<EcaAhp> ecaAhp = getEcaAhp(matrixParam.getIds());
            if (CollectionUtils.isNotEmpty(ecaAhp)) {
                Integer id = ecaAhp.get(0).getId();
                ahp.setId(id);
            }
            saveOrUpdate(ahp);
            dto.setMatrix(JSONUtil.parseArray(matrixParam.getColumnwise()));
            log.info("计算结果-->{}",dto);
            return dto;
        }

3.计算组归一

public List<BigDecimal> groupNormalization(List<BigDecimal> list) {
            DecimalFormat df = new DecimalFormat("#.0000");
            double sum = list.stream().mapToDouble(BigDecimal::doubleValue).sum();
            List<BigDecimal> res = new ArrayList<>();
            BigDecimal lastValue = new BigDecimal(1);
            //循环计算每级，最后一级用1减去签名所有级，保证总和为1.
            for (int i = 0; i < list.size() - 1; i++) {
                BigDecimal value = list.get(i).divide(new BigDecimal(sum), 4, BigDecimal.ROUND_HALF_UP);
                lastValue = lastValue.subtract(value);
                res.add(value);
            }
            res.add(new BigDecimal(df.format(lastValue)));
            return res;
        }

4.计算cr值

/**
         * 计算cr值
         *
         * @param dto
         * @return
         */
        public BigDecimal calCR(EcaAhp dto) {
            if (dto.getNumber() > 0 && dto.getNumber() < 3) {
                return new BigDecimal(0);
            }else if(dto.getNumber()<16) {
                BigDecimal me = new BigDecimal(dto.getMaxEigenvalue());
                BigDecimal order = new BigDecimal(dto.getNumber());
                BigDecimal fz = me.subtract(order);
                BigDecimal fm = order.subtract(new BigDecimal(1));
                BigDecimal ci = fz.divide(fm, 4, BigDecimal.ROUND_HALF_UP);
                log.debug("ci的值{}", ci);
                BigDecimal ri = new BigDecimal(RIEnum.getValue(dto.getNumber()));
                log.debug("ri的值{}", ri);
                BigDecimal cr = ci.divide(ri, 4, BigDecimal.ROUND_HALF_UP);
                log.debug("cr的值{}", cr);
                return cr;
            }else {
                return BigDecimal.ZERO;
            }
        }

5.ri值

public enum RIEnum {
        RI_NUMBER_1(1, 0d),
        RI_NUMBER_2(2, 0d),
        RI_NUMBER_3(3, 0.58d),
        RI_NUMBER_4(4, 0.90d),
        RI_NUMBER_5(5, 1.12d),
        RI_NUMBER_6(6, 1.24d),
        RI_NUMBER_7(7, 1.32d),
        RI_NUMBER_8(8, 1.41d),
        RI_NUMBER_9(9, 1.45d),
        RI_NUMBER_10(10, 1.49d),
        RI_NUMBER_11(11, 1.51d),
        RI_NUMBER_12(12, 1.54d),
        RI_NUMBER_13(13, 1.56d),
        RI_NUMBER_14(14, 1.58d),
        RI_NUMBER_15(15, 1.59d),
        ;
    
        private Integer number;
        private double ri;
    
        RIEnum(Integer number, double ri) {
            this.number = number;
            this.ri = ri;
        }
    
        public Integer getNumber() {
            return number;
        }
    
        public void setNumber(Integer number) {
            this.number = number;
        }
    
        public double getRi() {
            return ri;
        }
    
        public void setRi(double ri) {
            this.ri = ri;
        }
    
        public static double getValue(Integer num) {
            for (RIEnum data : RIEnum.values()) {
                if (data.number.equals(num)) {
                    return data.ri;
                }
            }
            return 0d;
        }