QFD2/QFD/algorithm/EntropyWeights.cpp

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

#include "EntropyWeights.h"
#include <QDebug>
#include <numeric>
#include <cmath>

EntropyWeights::EntropyWeights(const EntropyMat &mat, const QVector<bool> &direction)
    : ymin_(0.002), ymax_(0.996), mat_(mat), direction_(direction)
{
    index_num_ = mat_.count();
    if (index_num_ == 0) {
        sample_num_ = 0;
    } else {
        sample_num_ = mat_.at(0).count();
    }
}

void EntropyWeights::setYMin(double ymin)
{
    if (ymin < 0.002) {
        ymin_ = 0.002;
    } else if (ymin > ymax_) {
        return;
    }

    ymin_ = ymin;
}

void EntropyWeights::setYMax(double ymax)
{
    if (ymax > 0.996) {
        ymax_ = 0.996;
    } else if (ymax < ymin_) {
        return;
    }

    ymax_ = ymax;
}

void EntropyWeights::getWeights(QVector<double> &weights, QVector<double> &score)
{
    // 计算第j个指标下，第i个样本占该指标的比重p
    EntropyMat pMat;
    for (int i = 0; i < mat_.count(); i++) {
        pMat.append(QVector<double>(mat_.at(i).count(), 0));
        double sum = std::accumulate(mat_.at(i).begin(), mat_.at(i).end(), 0.0);
        for (int j = 0; j < mat_.at(i).count(); j++) {
            pMat[i][j] = mat_[i][j] / sum;
        }
    }

    double k = 1 / std::log(sample_num_);

    // 计算第j个指标熵值
    QVector<double> e(mat_.count(), 0);
    for (int i = 0; i < mat_.count(); i++) {
        //        QVector<double> f(mat_.at(i).count(), 0.0);
        double fSum = 0;
        for (int j = 0; j < mat_.at(i).count(); j++) {
            fSum += pMat[i][j] * std::log(pMat[i][j]);
        }
        e[i] = -k * fSum;
    }
    //    qDebug() << e;

    // 计算信息熵冗余度
    QVector<double> d(mat_.count(), 0);
    for (int i = 0; i < e.count(); i++) {
        d[i] = 1 - e[i];
    }

    // 求权值
    double dSum = std::accumulate(d.begin(), d.end(), 0.0);
    for (auto v : d) {
        weights.append(v / dSum);
    }

    for (int i = 0; i < sample_num_; ++i) {
        double s = 0;
        for (int j = 0; j < index_num_; j++) {
            s += pMat[j][i] * weights[j];
        }
        score.append(s * 100);
    }
}

/**
 * 实现正向或负向指标归一化，返回归一化后的数据矩阵
 */
void EntropyWeights::normalization()
{
    for (int i = 0; i < mat_.count(); i++) {
        double minValue = 0;
        double maxValue = 0;

        getMinMax(mat_.at(i), minValue, maxValue);

        bool dir = true;
        if (!direction_.isEmpty()) {
            dir = direction_.at(i);
        }
        if (dir) {
            for (int j = 0; j < mat_.at(i).count(); j++) {
                mat_[i][j] = (ymax_ - ymin_) * (mat_.at(i).at(j) - minValue) / (maxValue - minValue) + ymin_;
            }
        } else {
            for (int j = 0; j < mat_.at(i).count(); j++) {
                mat_[i][j] = (ymax_ - ymin_) * (maxValue - mat_.at(i).at(j)) / (maxValue - minValue) + ymin_;
            }
        }
    }
}

void EntropyWeights::getMinMax(const QVector<double> &in, double &min, double &max)
{
    if (in.count() > 0) {
        min = max = in.at(0);

        for (int i = 1; i < in.count(); i++) {
            if (in.at(i) < min) {
                min = in.at(i);
            } else if (in.at(i) > max) {
                max = in.at(i);
            }
        }
    }
}

void EntropyWeights::compute(QVector<double> &weights, QVector<double> &score)
{
    normalization();
    qDebug() << mat_;
    getWeights(weights, score);
    //    qDebug() << "mat_" << mat_;
}