c++语言实现FLSR

FLSR（Fuzzy Least Squares Regression）是一种模糊回归分析方法，可以用于处理带有不确定性的数据。下面是一个简单的C++程序，实现FLSR算法：

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

// 模糊回归分析
class FLSR {
public:
    // 计算权重矩阵
    void computeWeight(vector<double>& x, double sigma) {
        int n = x.size();
        W.resize(n);
        for (int i = 0; i < n; i++) {
            W[i].resize(n);
            for (int j = 0; j < n; j++) {
                W[i][j] = exp(-(x[i]-x[j])*(x[i]-x[j])/(2*sigma*sigma));
            }
        }
    }

    // 计算模糊输出矩阵
    void computeFuzzyOutput(vector<double>& y, double alpha) {
        int n = y.size();
        F.resize(n);
        for (int i = 0; i < n; i++) {
            F[i].resize(n);
            for (int j = 0; j < n; j++) {
                F[i][j] = exp(-alpha*(y[i]-y[j])*(y[i]-y[j]));
            }
        }
    }

    // 计算系数矩阵
    void computeCoeff(vector<double>& x, vector<double>& y, double alpha, double sigma) {
        int n = x.size();
        computeWeight(x, sigma);
        computeFuzzyOutput(y, alpha);
        Matrix A(n, n);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                A(i, j) = W[i][j]*F[i][j];
            }
        }
        Matrix B(n, 1);
        for (int i = 0; i < n; i++) {
            B(i, 0) = y[i];
        }
        Matrix C = A.inv() * B;
        for (int i = 0; i < n; i++) {
            a[i] = C(i, 0);
        }
    }

    // 预测
    double predict(double x) {
        double y = 0.0;
        int n = a.size();
        for (int i = 0; i < n; i++) {
            y += a[i] * exp(-(x-x[i])*(x-x[i])/(2*sigma*sigma));
        }
        return y;
    }

private:
    // 矩阵类
    class Matrix {
    public:
        Matrix(int rows, int cols) {
            data.resize(rows);
            for (int i = 0; i < rows; i++) {
                data[i].resize(cols);
            }
            this->rows = rows;
            this->cols = cols;
        }

        vector<double>& operator[](int i) {
            return data[i];
        }

        Matrix inv() {
            Matrix ret(rows, cols);
            double d = det();
            if (d == 0.0) {
                cerr << "error: singular matrix!" << endl;
                exit(1);
            }
            for (int i = 0; i < rows; i++) {
                for (int j = 0; j < cols; j++) {
                    Matrix tmp(rows-1, cols-1);
                    int r = 0;
                    for (int k = 0; k < rows; k++) {
                        if (k == i) {
                            continue;
                        }
                        int c = 0;
                        for (int l = 0; l < cols; l++) {
                            if (l == j) {
                                continue;
                            }
                            tmp[r][c] = data[k][l];
                            c++;
                        }
                        r++;
                    }
                    ret[j][i] = tmp.det() / d;
                    if ((i+j) % 2 == 1) {
                        ret[j][i] = -ret[j][i];
                    }
                }
            }
            return ret;
        }

        double det() {
            if (rows != cols) {
                cerr << "error: non-square matrix!" << endl;
                exit(1);
            }
            if (rows == 1) {
                return data[0][0];
            }
            if (rows == 2) {
                return data[0][0]*data[1][1] - data[0][1]*data[1][0];
            }
            double ret = 0.0;
            for (int i = 0; i < cols; i++) {
                Matrix tmp(rows-1, cols-1);
                int r = 0;
                for (int j = 1; j < rows; j++) {
                    int c = 0;
                    for (int k = 0; k < cols; k++) {
                        if (k == i) {
                            continue;
                        }
                        tmp[r][c] = data[j][k];
                        c++;
                    }
                    r++;
                }
                ret += data[0][i] * tmp.det() * (i%2==0 ? 1 : -1);
            }
            return ret;
        }

    private:
        vector<vector<double>> data;
        int rows, cols;
    };

    vector<vector<double>> W;  // 权重矩阵
    vector<vector<double>> F;  // 模糊输出矩阵
    vector<double> a;  // 系数矩阵
    double sigma = 0.5;  // 权重矩阵的标准差
    double alpha = 1.0;  // 模糊输出矩阵的参数
};

int main() {
    vector<double> x = {1, 2, 3, 4, 5};
    vector<double> y = {2.1, 4.2, 6.5, 8.4, 10.4};

    FLSR flsr;
    flsr.computeCoeff(x, y, 1.0, 0.5);

    cout << "系数矩阵: ";
    for (auto i : flsr.a) {
        cout << i << " ";
    }
    cout << endl;

    cout << "预测值: " << flsr.predict(6) << endl;

    return 0;
}

该程序实现了FLSR算法，并在一个简单的数据集上进行了测试。程序的输入是一组x和y的值，以及权重矩阵的标准差sigma和模糊输出矩阵的参数alpha。输出是系数矩阵和给定x值的预测y值。