向量自回归 的C++ 带类的自带矩阵运算的代码实现及案例

以下是一个简单的向量自回归的C++代码实现，包含自带矩阵运算和类的实现：

#include <iostream>
#include <vector>

using namespace std;

class Vector {
public:
    int n; // 向量维度
    vector<double> data; // 向量数据

    // 构造函数
    Vector(int dim) {
        n = dim;
        data.resize(n, 0.0);
    }

    // 随机初始化向量
    void rand() {
        for (int i = 0; i < n; i++) {
            data[i] = (double)rand() / RAND_MAX;
        }
    }

    // 向量加法
    Vector operator+ (const Vector& v) const {
        Vector res(n);
        for (int i = 0; i < n; i++) {
            res.data[i] = data[i] + v.data[i];
        }
        return res;
    }

    // 向量减法
    Vector operator- (const Vector& v) const {
        Vector res(n);
        for (int i = 0; i < n; i++) {
            res.data[i] = data[i] - v.data[i];
        }
        return res;
    }

    // 向量数乘
    Vector operator* (double x) const {
        Vector res(n);
        for (int i = 0; i < n; i++) {
            res.data[i] = data[i] * x;
        }
        return res;
    }

    // 向量点积
    double dot(const Vector& v) const {
        double res = 0.0;
        for (int i = 0; i < n; i++) {
            res += data[i] * v.data[i];
        }
        return res;
    }

    // 向量转置
    Vector T() const {
        Vector res(n);
        for (int i = 0; i < n; i++) {
            res.data[i] = data[i];
        }
        return res;
    }
};

class Matrix {
public:
    int row, col; // 矩阵行列数
    vector<Vector> data; // 矩阵数据

    // 构造函数
    Matrix(int r, int c) {
        row = r;
        col = c;
        data.resize(row, Vector(col));
    }

    // 随机初始化矩阵
    void rand() {
        for (int i = 0; i < row; i++) {
            data[i].rand();
        }
    }

    // 矩阵加法
    Matrix operator+ (const Matrix& mat) const {
        Matrix res(row, col);
        for (int i = 0; i < row; i++) {
            res.data[i] = data[i] + mat.data[i];
        }
        return res;
    }

    // 矩阵减法
    Matrix operator- (const Matrix& mat) const {
        Matrix res(row, col);
        for (int i = 0; i < row; i++) {
            res.data[i] = data[i] - mat.data[i];
        }
        return res;
    }

    // 矩阵数乘
    Matrix operator* (double x) const {
        Matrix res(row, col);
        for (int i = 0; i < row; i++) {
            res.data[i] = data[i] * x;
        }
        return res;
    }

    // 矩阵乘法
    Matrix operator* (const Matrix& mat) const {
        Matrix res(row, mat.col);
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < mat.col; j++) {
                res.data[i].data[j] = data[i].dot(mat.col(j));
            }
        }
        return res;
    }

    // 矩阵转置
    Matrix T() const {
        Matrix res(col, row);
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                res.data[j].data[i] = data[i].data[j];
            }
        }
        return res;
    }
};

// 向量自回归
Matrix VAR(vector<Vector> X, int p) {
    int n = X.size(); // 样本数量
    int m = X[0].n; // 向量维度

    // 构造样本矩阵
    Matrix Y(n - p, m * p);
    for (int i = 0; i < n - p; i++) {
        for (int j = 0; j < p; j++) {
            for (int k = 0; k < m; k++) {
                Y.data[i].data[j * m + k] = X[i + j].data[k];
            }
        }
    }

    // 构造目标矩阵
    Matrix Xn(n - p, m);
    for (int i = 0; i < n - p; i++) {
        Xn.data[i] = X[i + p];
    }

    // 求解VAR系数矩阵
    Matrix Yt = Y.T();
    Matrix C = (Yt * Y).inv() * Yt * Xn;

    return C;
}

int main() {
    // 构造样本向量
    vector<Vector> X(100);
    for (int i = 0; i < 100; i++) {
        X[i] = Vector(2);
        X[i].data[0] = sin(i * 0.05);
        X[i].data[1] = cos(i * 0.05);
    }

    // 向量自回归
    Matrix C = VAR(X, 2);
    cout << "VAR coefficient matrix:" << endl;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 4; j++) {
            cout << C.data[i].data[j] << " ";
        }
        cout << endl;
    }

    return 0;
}

以上代码实现了一个简单的向量自回归，包含自带矩阵运算和类的实现。其中，`Vector`类表示向量，`Matrix`类表示矩阵。`VAR`函数实现了向量自回归的算法，输入为样本向量和自回归阶数，输出为自回归系数矩阵。在主函数中，构造了一个简单的样本向量，并调用`VAR`函数求解自回归系数矩阵。