QFD2/QFD/algorithm/MatterElementAnalysis.cpp

//
// Created by Austin on 2023/10/11.
//

#include "MatterElementAnalysis.h"

MatterElementAnalysis::MatterElementAnalysis(const MEAMat &mat, const MEARangeMat &ranges)
        : mat_(mat), ranges_(ranges) {
    sample_num_ = mat_.count();
    if (sample_num_ == 0) {
        index_num_ = 0;
    } else {
        index_num_ = mat_.at(0).count();
    }

    for (int i = 0; i < sample_num_; ++i) {
        MEAMat cvtMat;
        for (int j = 0; j < index_num_; ++j) {
            cvtMat.append(QVector<double>(ranges_.count() - 1, 0.0));
        }
        range_cvt_.append(cvtMat);
    }
    for (int i = 0; i < sample_num_; ++i) {
        range_weights_.append(QVector<double>(ranges_.count() - 1, 0.0));
    }
}

void MatterElementAnalysis::evaluate() {
    //根据关联函数更新转换矩阵
    for (int s = 0; s < sample_num_; ++s) {
        for (int i = 0; i < index_num_; ++i) {
            double val = mat_.at(s).at(i);
            associatedValue(s, i, val);
        }
    }
    QVector<double> weights = {0.189, 0.203, 0.052, 0.162, 0.202, 0.151, 0.041};
    evaluationlevel(weights);
}

void MatterElementAnalysis::associatedValue(int sam, int index, double value) {
    auto pFunc = [](double v, double left, double right) {
        return std::abs(v - (left + right) / 2) - (right - left) / 2;
    };

    double r = 0;
    for (int i = 0; i < ranges_.count() - 1; ++i) //i是等级，index是指标
    {
        Q_ASSERT(ranges_.at(i).at(index).index == index);
        double minValue = ranges_.at(i).at(index).min_value;
        double maxValue = ranges_.at(i).at(index).max_value;
        double minend = ranges_.last().at(index).min_value;
        double maxend = ranges_.last().at(index).max_value;
        double r1 = pFunc(value, minValue, maxValue);
        double r2 = pFunc(value, minend, maxend);

        if (abs(r1 - r2) <= 0.00000001) {
            r = -r1 - 1;
        } else {
            r = r1 / (r2 - r1);
        }
        range_cvt_[sam][index][i] = r;
        //结果放在range_cvt_
    }
}

void MatterElementAnalysis::evaluationlevel(const QVector<double> &weights) { //输入计算出来的关联度，权值
    //计算一个样本权值之后的总关联度
    double r;
    for (int i = 0; i < sample_num_; ++i) //样本
        for (int j = 0; j < ranges_.count() - 1; ++j) {                                 //等级
            r = 0;
            for (int k = 0; k < index_num_; ++k) { //指标
                r = r + range_cvt_[i][k][j] * weights[k];
            }
            range_weights_[i][j] = r;
        }
}

const MEAMat &MatterElementAnalysis::getRangeWeights() const {
    return range_weights_;
}

QVector<int> MatterElementAnalysis::getBestIndex() const {
    auto maxLoc = [](const QVector<double> &v) {
        int index = 0;
        double maxValue = v.at(0);
        for (int i = 1; i < v.count(); ++i) {
            if (v.at(i) > maxValue) {
                maxValue = v.at(i);
                index = i;
            }
        }
        return index;
    };
    QVector<int> result;
    for (const auto &s: range_weights_) {
        result << maxLoc(s) + 1;
    }

    return result;
}