//将表格中的数据读取到判断矩阵中
 private JudgeMatrix ReadDataToMatrix()
 {
     int n = _judgeMatrixPair.NormalGen.X;
     JudgeMatrix temp = new JudgeMatrix(n);
     for (int i = 0; i < n; i++)
     {
         for (int j = 0; j < n; j++)
         {
             double d = double.Parse(dataGrid.Rows[i].Cells[j].Value.ToString());
             temp[i, j] = d;
         }
     }
     return temp;
 }
 public JudgeMatrixDisplayForm(JudgeMatrix judgeMatrix)
     : this()
 {
     _judgeMatrix = judgeMatrix;
     Init();
 }
Exemple #3
0
        /// <summary>
        /// 初始化决策模型
        /// </summary>
        private void InitModel()
        {
            //创建第一层
            Factor factor = new Factor("Z");
            Level toplevel = new Level(null, new List<Factor>() { factor }, null, null);
            //设置初始化的模型
            _ahpModel = new AhpModel(toplevel);

            //构造第二层
            //第二层因素
            IList<Factor> factors2 = new List<Factor>
                {
                    new Factor("A1"),
                    new Factor("A2"),
                    new Factor("A3"),
                    new Factor("A4"),
                };
            //第二层关系矩阵
            Matrix level2Relation = new Matrix(4, 1);
            level2Relation.InsertDataFromList(new List<double> { 1, 1, 1, 1 });
            //第二层判断矩阵,初始化为空
            JudgeMatrix level2JudugeMatrix1 = new JudgeMatrix(4);
            //加入到判断矩阵序列
            Dictionary<Factor, JudgeMatrix> level2Judges = new Dictionary<Factor, JudgeMatrix>();
            level2Judges.Add(toplevel.Factors[0], level2JudugeMatrix1);
            Level level2 = new Level(toplevel, factors2, level2Relation, level2Judges);
            //加入到模型中
            _ahpModel.PushLevel(level2);

            //构造第三层次
            IList<Factor> factors3 = new List<Factor>
                {
                    new Factor("B1"){Direction = FactorDirection.Negative},
                    new Factor("B2"),
                    new Factor("B3"),
                    new Factor("B4"),
                    new Factor("B5"),
                    new Factor("B6"),
                    new Factor("B7"),
                    new Factor("B8"){Direction = FactorDirection.Negative},
                    new Factor("B9"),
                    new Factor("B10"),
                    new Factor("B11"),
                    new Factor("B12"),
                    new Factor("B13"),
                    new Factor("B14"),
                };
            //第三层关系矩阵
            Matrix level3Relation = new Matrix(14, 4);
            level3Relation.InsertDataFromList(new List<double>
                {
                    1,
                    0,
                    0,
                    0,
                    1,
                    0,
                    0,
                    0,
                    1,
                    0,
                    0,
                    0,
                    0,
                    1,
                    0,
                    0,
                    0,
                    1,
                    0,
                    0,
                    0,
                    1,
                    0,
                    0,
                    0,
                    1,
                    0,
                    0,
                    0,
                    0,
                    1,
                    0,
                    0,
                    0,
                    1,
                    0,
                    0,
                    0,
                    1,
                    0,
                    0,
                    0,
                    0,
                    1,
                    0,
                    0,
                    0,
                    1,
                    0,
                    0,
                    0,
                    1,
                    0,
                    0,
                    0,
                    1
                });
            //第三层判断矩阵
            JudgeMatrix level3JudugeMatrix1 = new JudgeMatrix(3);
            JudgeMatrix level3JudugeMatrix2 = new JudgeMatrix(4);
            JudgeMatrix level3JudugeMatrix3 = new JudgeMatrix(3);
            JudgeMatrix level3JudugeMatrix4 = new JudgeMatrix(4);
            //加入到判断矩阵序列
            Dictionary<Factor, JudgeMatrix> level3Judges = new Dictionary<Factor, JudgeMatrix>();
            level3Judges.Add(level2.Factors[0], level3JudugeMatrix1);
            level3Judges.Add(level2.Factors[1], level3JudugeMatrix2);
            level3Judges.Add(level2.Factors[2], level3JudugeMatrix3);
            level3Judges.Add(level2.Factors[3], level3JudugeMatrix4);
            Level level3 = new Level(level2, factors3, level3Relation, level3Judges);
            //加入到模型中
            _ahpModel.PushLevel(level3);
        }
Exemple #4
0
 public static void JudgeMatrixTest()
 {
     JudgeMatrix jm1 = new JudgeMatrix(5, "测试矩阵");
     jm1.InsertDataFromList(
         new List<double>
             {
                 1,
                 0.5,
                 4,
                 3,
                 3,
                 2,
                 1,
                 7,
                 5,
                 5,
                 1/4.0,
                 1/7.0,
                 1,
                 1/2.0,
                 1/3.0,
                 1/3.0,
                 1/5.0,
                 2,
                 1,
                 1,
                 1/3.0,
                 1/5.0,
                 3,
                 1,
                 1
             });
     jm1.DisplayMatrix(DataHelper.ConsoloOutput);
     double eiginValue;
     var vect1 = jm1.SingleFactorWightVect(out eiginValue);
     vect1.DisplayMatrix(DataHelper.ConsoloOutput);
     Console.WriteLine("测试矩阵的\n特征值={3},\nCI={0},\nRI={1},\nCR={2}", jm1.CI, jm1.RI, jm1.CR, eiginValue);
 }
Exemple #5
0
        public static void AhpModelTest()
        {
            //构造第一层
            IList<Factor> factors1 = new List<Factor>() { new Factor("Z") };
            Level level1 = new Level(null, factors1, null, null);
            AhpModel ahpModel = new AhpModel(level1);

            //构造第二层
            //第二层因素
            IList<Factor> factors2 = new List<Factor>
                {
                    new Factor("A1"),
                    new Factor("A2"),
                    new Factor("A3"),
                    new Factor("A4"),
                    new Factor("A")
                };
            //第二层关系矩阵
            Matrix level2Relation = new Matrix(5, 1);
            level2Relation.InsertDataFromList(new List<double> { 1, 1, 1, 1, 1 });
            //第二层判断矩阵
            JudgeMatrix level2JudugeMatrix1 = new JudgeMatrix(5);
            level2JudugeMatrix1.InsertDataFromList(new List<double>
                {
                    1,
                    1/2.0,
                    4,
                    3,
                    3,
                    2,
                    1,
                    7,
                    5,
                    5,
                    1/4,
                    1/7,
                    1,
                    1/2.0,
                    1/3.0,
                    1/3.0,
                    1/5.0,
                    2,
                    1,
                    1,
                    1/3.0,
                    1/5.0,
                    3,
                    1,
                    1
                });
            //加入到判断矩阵序列
            Dictionary<Factor, JudgeMatrix> level2Judges = new Dictionary<Factor, JudgeMatrix>();
            level2Judges.Add(level1.Factors[0], level2JudugeMatrix1);
            Level level2 = new Level(level1, factors2, level2Relation, level2Judges);
            //加入到模型中
            ahpModel.PushLevel(level2);

            //构造第三层次
            IList<Factor> factors3 = new List<Factor>
                {
                    new Factor("B1"),
                    new Factor("B2"),
                    new Factor("B3"),
                };
            //第三层关系矩阵
            Matrix level3Relation = new Matrix(3, 5);
            level3Relation.InsertDataFromList(new List<double>
                {
                    1,
                    1,
                    1,
                    1,
                    1,
                    1,
                    1,
                    1,
                    1,
                    1,
                    1,
                    1,
                    1,
                    1,
                    1
                });
            //第三层判断矩阵
            JudgeMatrix level3JudugeMatrix1 = new JudgeMatrix(3);
            level3JudugeMatrix1.InsertDataFromList(new List<double>
                {
                    1,
                    2,
                    5,
                    1/2.0,
                    1,
                    2,
                    1/5.0,
                    1/2.0,
                    1
                });
            JudgeMatrix level3JudugeMatrix2 = new JudgeMatrix(3);
            level3JudugeMatrix2.InsertDataFromList(new List<double>
                {
                    1,
                    1/3.0,
                    1/8.0,
                    3,
                    1,
                    1/3.0,
                    8,
                    3,
                    1
                });
            JudgeMatrix level3JudugeMatrix3 = new JudgeMatrix(3);
            level3JudugeMatrix3.InsertDataFromList(new List<double>
                {
                    1,
                    1,
                    3,
                    1,
                    1,
                    3,
                    1/3.0,
                    1/3.0,
                    1
                });
            JudgeMatrix level3JudugeMatrix4 = new JudgeMatrix(3);
            level3JudugeMatrix4.InsertDataFromList(new List<double>
                {
                    1,
                    3,
                    4,
                    1/3.0,
                    1,
                    1,
                    1/4.0,
                    1,
                    1
                });
            JudgeMatrix level3JudugeMatrix5 = new JudgeMatrix(3);
            level3JudugeMatrix5.InsertDataFromList(new List<double>
                {
                    1,
                    1,
                    1/4.0,
                    1,
                    1,
                    1/4.0,
                    4,
                    4,
                    1
                });
            //加入到判断矩阵序列
            Dictionary<Factor, JudgeMatrix> level3Judges = new Dictionary<Factor, JudgeMatrix>();
            level3Judges.Add(level2.Factors[0], level3JudugeMatrix1);
            level3Judges.Add(level2.Factors[1], level3JudugeMatrix2);
            level3Judges.Add(level2.Factors[2], level3JudugeMatrix3);
            level3Judges.Add(level2.Factors[3], level3JudugeMatrix4);
            level3Judges.Add(level2.Factors[4], level3JudugeMatrix5);
            Level level3 = new Level(level2, factors3, level3Relation, level3Judges);
            //加入到模型中
            ahpModel.PushLevel(level3);

            //测试数据
            ahpModel.GetLevelInfo(3).GetTotalWeightVect().DisplayMatrix(DataHelper.ConsoloOutput);
        }
Exemple #6
0
        //使用改进的方法构造判断矩阵
        public static IList<JudgeMatrix> GetJudgeMatrices(Matrix relationMatrix, IList<Factor> parentFactors, IList<Factor> currentFacors)
        {
            IList<JudgeMatrix> judgeMatrices = new List<JudgeMatrix>();

            //按照上一层中的各个因素逐个处理
            for (int j = 0; j < relationMatrix.Y; j++)
            {
                //获得上层某因素影响的下层因素
                IList<Factor> affectedFactors = new List<Factor>();
                for (int i = 0; i < relationMatrix.X; i++)
                {
                    if (Math.Abs(relationMatrix[i, j] - 0) > 0.00001)
                        affectedFactors.Add(currentFacors[i]);
                }
                //构造一个空的判断矩阵,
                int affectedCount = affectedFactors.Count;
                JudgeMatrix judgeMatrix = new JudgeMatrix(affectedCount);

                #region 然后使用改进的构造方法构造判断矩阵

                //打印提示信息
                Console.WriteLine("请输入因素{0}影响的{1}个因素的重要性排序,\n同时给出最重要与最不重要的因素比率", parentFactors[j].Name, affectedCount);
                Console.Write("被影响的因素包括:");
                for (int i = 0; i < affectedCount; i++)
                {
                    Console.Write("{0} {1},", i, affectedFactors[i].Name);
                }
                Console.WriteLine();
                //各个专家给出的排序的表
                IList<IList<int>> rateTable = new List<IList<int>>();
                IList<int> pList = new List<int>();
                //表示第几个专家给出的排序
                int rateCount = 0;
                //循环读取专家的建议排序,然后放入rateTable中
                while (true)
                {
                    rateCount++;
                    //获取排序
                    var readRate = DataHelper.ReadValus<int>(string.Format("请输入第{0}个专家的排序,从0开始!", rateCount), affectedCount);
                    rateTable.Add(readRate);
                    //获取p
                    int p = DataHelper.ReadValus<int>(string.Format("请输入第{0}个专家的的最重要与最不重要的因素比率", rateCount), 1)[0];
                    pList.Add(p);
                    //是否继续添加,如果不添加了,就跳出
                    if (!DataHelper.ReadBool("是否要继续添加重要性排序?"))
                        break;
                }
                //计算根据rateTable和pList构造判断矩阵
                double pAvg = pList.Average();
                IList<double> aList = new List<double>();
                //对被影响的因素逐个处理,生成各个被影响因素的平均赋权值
                for (int i = 0; i < affectedCount; i++)
                {
                    int sumIndex = 0, avgIndex = 0, pow = 0;
                    for (int k = 0; k < rateCount; k++)
                    {
                        sumIndex += (rateTable[k].IndexOf(i) + 1);
                    }
                    avgIndex = sumIndex / rateCount;
                    pow = affectedCount - avgIndex + 1;
                    aList.Add(pow);
                }
                //对判断矩阵逐个处理插入值
                for (int m = 0; m < affectedCount; ++m)
                {
                    for (int n = 0; n < affectedCount; ++n)
                    {
                        if (aList[m] >= aList[n])
                        {
                            var numerator = aList[m] - aList[n];
                            var denominator = aList.Max() - aList.Min();
                            judgeMatrix[m, n] = numerator / denominator * (pAvg - 1) + 1;
                        }
                        else
                        {
                            var numerator = aList[n] - aList[m];
                            var denominator = aList.Max() - aList.Min();
                            judgeMatrix[m, n] = 1 / (numerator / denominator * (pAvg - 1) + 1);
                        }
                    }
                }
                #endregion

                judgeMatrices.Add(judgeMatrix);
            }

            return judgeMatrices;
        }
Exemple #7
0
 //根据关系矩阵构造判断矩阵
 public static IList<JudgeMatrix> GetJudgeMatrices(Matrix relationMatrix)
 {
     IList<JudgeMatrix> judgeMatrices = new List<JudgeMatrix>();
     for (int j = 0; j < relationMatrix.Y; j++)
     {
         var affectcount = 0;
         for (int i = 0; i < relationMatrix.X; i++)
         {
             if (Math.Abs(relationMatrix[i, j] - 0) > 0.00001)
                 affectcount++;
         }
         JudgeMatrix judgeMatrix = new JudgeMatrix(affectcount);
         //可以选择判断矩阵的构造方式
         judgeMatrix.InsertMatrix(DataHelper.ConsoleArrayInput);
         judgeMatrices.Add(judgeMatrix);
     }
     return judgeMatrices;
 }
Exemple #8
0
 /// <summary>
 /// 根据关系矩阵生成空的判断矩阵,每一次关系矩阵修改,都必须调用这个函数
 /// </summary>
 /// <param name="relationMatrix">关系矩阵</param>
 private void UpdateJudgeMatrices()
 {
     //Todo:考虑实现一种不清空关系矩阵的方法
     for (int i = 0; i < _relationMatrix.Y; i++)
     {
         //查找上一层第i个因素影响的本层因素数量
         int affectcount = 0;
         for (int j = 0; j < _relationMatrix.X; j++)
         {
             affectcount++;
         }
         //如果影响的因素数量不为不为0,则增加一个判断矩阵
         if (affectcount != 0)
         {
             JudgeMatrix jm = new JudgeMatrix(affectcount);
             JudgeMatrices.Add(Parent.Factors[i], jm);
         }
     }
 }
Exemple #9
0
 /// <summary>
 /// 设置本层次相对于上一层次中某个因素的的判断矩阵
 /// </summary>
 /// <param name="parentFactor"></param>
 /// <param name="judgeMatrix"></param>
 private void SetJudgeMatrix(Factor parentFactor, JudgeMatrix judgeMatrix)
 {
     //检查parentFactor是否为上一层次总的因素
     if (!Parent.Factors.Contains(parentFactor))
     {
         throw new CustomeExcetpion("上一层不包含指定的因素");
     }
     //检查传入的判断矩阵是否符合要求
     judgeMatrix.CheckJudgeMatrix();
     //设置
     JudgeMatrices.Add(parentFactor, judgeMatrix);
 }
        //通过表格中的数据计算判断矩阵
        private JudgeMatrix CalJudgeMatrix()
        {
            JudgeMatrix judgeMatrix = new JudgeMatrix(FactorCount);

            //各个专家给出的排序的表
            IList<IList<int>> rateTable = new List<IList<int>>();
            IList<int> pList = new List<int>();
            //表示专家给出的排序个数
            //要排除最后一行空行
            int rateCount = _dataTable.Rows.Count;
            //逐行处理,将数据填充到以上两个List中
            for (int i = 0; i < rateCount; i++)
            {
                //获取当前行的所有数据项
                var items = _dataTable.Rows[i].ItemArray;
                //用来保存排序数据项
                IList<int> tempList = new List<int>();
                for (int j = 0; j < FactorCount; j++)
                {
                    tempList.Add((int)items[j]);
                }
                rateTable.Add(tempList);
                //填充p
                pList.Add((int)items[FactorCount]);
            }

            //计算根据rateTable和pList构造判断矩阵
            double pAvg = pList.Average();
            IList<double> aList = new List<double>();
            //对被影响的因素逐个处理,生成各个被影响因素的平均赋权值
            for (int i = 0; i < FactorCount; i++)
            {
                int sumIndex = 0, avgIndex = 0, pow = 0;
                for (int k = 0; k < rateCount; k++)
                {
                    sumIndex += (rateTable[k].IndexOf(i) + 1);
                }
                avgIndex = sumIndex / rateCount;
                pow = FactorCount - avgIndex + 1;
                aList.Add(pow);
            }
            //对判断矩阵逐个处理插入值
            for (int m = 0; m < FactorCount; ++m)
            {
                for (int n = 0; n < FactorCount; ++n)
                {
                    if (aList[m] >= aList[n])
                    {
                        var numerator = aList[m] - aList[n];
                        var denominator = aList.Max() - aList.Min();
                        judgeMatrix[m, n] = numerator / denominator * (pAvg - 1) + 1;
                    }
                    else
                    {
                        var numerator = aList[n] - aList[m];
                        var denominator = aList.Max() - aList.Min();
                        judgeMatrix[m, n] = 1 / (numerator / denominator * (pAvg - 1) + 1);
                    }
                }
            }
            return judgeMatrix;
        }