修复使用层次分析法时的输入数据错误;

修改层次分析法接口;

QFD/algorithm/HierarchicalAnalysis.cpp

@@ -2,11 +2,11 @@
 #include <QtMath>
 #include <QDebug>
 
-HierarchicalAnalysis::HierarchicalAnalysis(const QStringList &nodes, const QVector<qreal> &nxnValus)
-    : m_nodes(nodes),
-      m_sqartnValues(QVector<double>(nodes.count(), 0)),
-      m_weights(QVector<double>(nodes.count(), 0)),
-      m_averageWeights(QVector<double>(nodes.count(), 0)),
+HierarchicalAnalysis::HierarchicalAnalysis(int columnCount, const QVector<qreal> &nxnValus)
+    : m_columnCount(columnCount),
+      m_sqartnValues(QVector<double>(m_columnCount, 0)),
+      m_weights(QVector<double>(m_columnCount, 0)),
+      m_averageWeights(QVector<double>(m_columnCount, 0)),
       m_CI(0),
       m_CR(0)
 {
@@ -18,10 +18,10 @@ void HierarchicalAnalysis::calc(const QVector<qreal> &nxnValus)
 {
     // qDebug() << "HierarchicalAnalysis nxnValus" << nxnValus;
 
-    QVector<qreal> nodeMul(m_nodes.count(), 1);
-    for (int m = 0; m < m_nodes.count(); ++m) {
-        for (int n = 0; n < m_nodes.count(); ++n) {
-            nodeMul[m] *= nxnValus[m * m_nodes.count() + n];
+    QVector<qreal> nodeMul(m_columnCount, 1);
+    for (int m = 0; m < m_columnCount; ++m) {
+        for (int n = 0; n < m_columnCount; ++n) {
+            nodeMul[m] *= nxnValus[m * m_columnCount + n];
         }
     }
     //    qDebug() << "nodeMul" << nodeMul;
@@ -41,33 +41,33 @@ void HierarchicalAnalysis::calc(const QVector<qreal> &nxnValus)
     // qDebug() << "weights" << m_weights;
 
     // m0*w0+m1*w1+m2*w2+m3*w3...mn*wn
-    for (int m = 0; m < m_nodes.count(); ++m) {
-        for (int n = 0; n < m_nodes.count(); ++n) {
-            m_averageWeights[m] += nxnValus[m * m_nodes.count() + n] * m_weights[n];
+    for (int m = 0; m < m_columnCount; ++m) {
+        for (int n = 0; n < m_columnCount; ++n) {
+            m_averageWeights[m] += nxnValus[m * m_columnCount + n] * m_weights[n];
         }
     }
 
     //    qDebug() << "averageWeights" << m_averageWeights;
 
     // Awi/Wi
-    QVector<qreal> awiDividedWi(m_nodes.count(), 0);
+    QVector<qreal> awiDividedWi(m_columnCount, 0);
     qreal awiDividedWiAverage = 0;
-    for (int m = 0; m < m_nodes.count(); ++m) {
+    for (int m = 0; m < m_columnCount; ++m) {
         awiDividedWi[m] = m_averageWeights[m] / m_weights[m];
         awiDividedWiAverage += awiDividedWi[m];
     }
-    awiDividedWiAverage /= m_nodes.count();
+    awiDividedWiAverage /= m_columnCount;
 
     //    qDebug() << "awiDividedWi" << awiDividedWi;
 
     // CI=(λ-n)/(n-1)
-    m_CI         = (awiDividedWiAverage - m_nodes.count()) / (m_nodes.count() - 1);
-    qreal result = m_nodes.count() <= 10 ? RI[m_nodes.count() - 1] : RI[9];
+    m_CI         = (awiDividedWiAverage - m_columnCount) / (m_columnCount - 1);
+    qreal result = m_columnCount <= 10 ? RI[m_columnCount - 1] : RI[9];
     if (qFuzzyCompare(result, 0)) {
         m_CR = 0;
     } else {
         m_CR = m_CI / result;
     }
 
-    //    qDebug() << RI[m_nodes.count() - 1] << "m_CI" << m_CI << "m_CR" << m_CR;
+    //    qDebug() << RI[m_columnCount - 1] << "m_CI" << m_CI << "m_CR" << m_CR;
 }

QFD/algorithm/HierarchicalAnalysis.h

@@ -23,13 +23,11 @@ public:
      *          HierarchicalAnalysis cc(ll, nn);
      *          qDebug() << cc.consitst();
      */
-    HierarchicalAnalysis(const QStringList &nodes, const QVector<qreal> &nxnValus);
+    HierarchicalAnalysis(int columnCount, const QVector<qreal> &nxnValus);
 
     const QVector<qreal> &getWeights() const { return m_weights; }
     const QVector<qreal> &getaverageWeights() const { return m_averageWeights; }
 
-    const QStringList &getNodes() const { return m_nodes; }
-
     qreal CI() const { return m_CI; }
     qreal CR() const { return m_CR; }
 
@@ -46,7 +44,7 @@ private:
     const qreal thd    = 0.1;
     void calc(const QVector<qreal> &nxnValus);
 
-    QStringList m_nodes;
+    int m_columnCount;
     QVector<qreal> m_sqartnValues;
     QVector<qreal> m_weights;
     QVector<qreal> m_averageWeights;

QFD/algorithm/test_main.cpp

@@ -100,7 +100,7 @@ void testHA()
                           3, 1.0 / 5.0, 1.0 / 3.0, 5,         3,         1,         5, 3,         3,
                           3, 1.0 / 3.0, 1.0 / 5.0, 1,         1.0 / 7.0, 1.0 / 3.0, 5, 5,         1.0 / 3.0,
                           7, 1,         3,         3,         3,         1.0 / 3.0, 3, 1.0 / 3.0, 1 };
-    HierarchicalAnalysis cc(ll, nn);
+    HierarchicalAnalysis cc(ll.size(), nn);
     qDebug() << cc.consitst();
     QVector<qreal> m_weights = cc.getWeights();
     qDebug() << m_weights;

QFD/common/DataEvaluator.cpp

@@ -92,11 +92,9 @@ bool DataEvaluator::evaluateWeightFromExpert()
         for (int i = 1; i < mind->levels(); i++) {
             for (CNodeData node : mind->nodesInLevel(i)) {
                 QList<CNodeData> subNodes = mind->subNodes(node);
-                QStringList matrixStr;
-                QVector<qreal> nxnValus(subNodes.size(), 0.0001);  // n x n矩阵
+                QVector<qreal> nxnValus;  // n x n矩阵
                 for (int j = 0; j < subNodes.size(); j++) {
                     QString abs = subNodes[j].name;
-                    matrixStr.append(abs);
                     for (int k = 0; k < subNodes.size(); k++) {
                         QString ord = subNodes[k].name;
                         QString key = abs + "-" + ord;
@@ -110,9 +108,9 @@ bool DataEvaluator::evaluateWeightFromExpert()
                         nxnValus.append(v);
                     }
                 }
-                QScopedPointer<HierarchicalAnalysis> ha(new HierarchicalAnalysis(matrixStr, nxnValus));
+                QScopedPointer<HierarchicalAnalysis> ha(new HierarchicalAnalysis(subNodes.size(), nxnValus));
                 QVector<qreal> weights = ha->getWeights();
-                qDebug() << __FUNCTION__ << __LINE__ << expertId << matrixStr << weights << endl;
+                qDebug() << __FUNCTION__ << __LINE__ << expertId << nxnValus << weights << endl;
             }
         }
     }

QFD/common/MindEvaluation.cpp

@@ -100,7 +100,7 @@ void MindEvaluation::computeSingleWeights()
                         }
                     }
                 }
-                QScopedPointer<HierarchicalAnalysis> ha(new HierarchicalAnalysis(s.childs, nxnValus));
+                QScopedPointer<HierarchicalAnalysis> ha(new HierarchicalAnalysis(s.childs.size(), nxnValus));
                 QVector<qreal> weights = ha->getWeights();
 
                 for (int c = 0; c < s.childs.size(); ++c) {
@@ -346,7 +346,7 @@ void MindEvaluation::computeOneEntry(const QList<NodeMatrixInfo *> &nmInfos, QLi
                         }
                     }
                 }
-                QScopedPointer<HierarchicalAnalysis> ha(new HierarchicalAnalysis(s.childs, nxnValus));
+                QScopedPointer<HierarchicalAnalysis> ha(new HierarchicalAnalysis(s.childs.size(), nxnValus));
                 QVector<qreal> weights = ha->getWeights();
 
                 for (int c = 0; c < s.childs.size(); ++c) {