yauntyour's Blog

MatLab.cpp

2026-04-25T07:25:41Z

MatLab-cpp

简单的C++绘图库，由OpenGL原生实现，依赖于GLFW创建窗口。

基本使用

#include "matlab.hpp"
#include <cmath>
#include <vector>
#include <iostream>

int main()
{
    using namespace matplot;

    std::vector<float> x = linspace(-4 * acos(-1), 4 * acos(-1), 100);
    std::vector<float> y1, y2;
    for (float xi : x)
    {
        y1.push_back(sin(xi));
        y2.push_back(cos(xi));
    }

    // === 创建一个窗口 ===
    Figure *fig1 = figure();
    auto axes1 = fig1->gca();
    axes1->setTitle("Sine and Cosine Waves");
    axes1->setXLabel("X");
    axes1->setYLabel("Y");
    axes1->grid(true);

    plot(axes1, x, y1, "b-");
    plot(axes1, x, y2, "r--");

    // === 主渲染循环 ===
    std::vector<Figure *> figures = {fig1};
    bool anyOpen = true;

    while (anyOpen)
    {
        anyOpen = false;
        for (auto fig : figures)
        {
            if (fig && fig->window && !glfwWindowShouldClose(fig->window))
            {
                fig->render();
                glfwSwapBuffers(fig->window);
                anyOpen = true;
            }
        }
        glfwPollEvents();
        std::this_thread::sleep_for(std::chrono::milliseconds(16));
    }

    // === 清理 ===
    delete fig1;
    glfwTerminate();

    return 0;
}

作为示波器：

// main.cpp - 示波器功能（固定时间窗口滚动显示）
#include "matlab.hpp"
#include <cmath>
#include <vector>
#include <iostream>

int main()
{
    using namespace matplot;

    Figure *fig = figure();
    auto axes = fig->gca();
    axes->setTitle("Oscilloscope - Real-time Sine Wave");
    axes->setXLabel("Time (s)");
    axes->setYLabel("Amplitude");
    axes->grid(true);
    axes->setDataRange(-1.8f, 1.8f, -3.0f, 3.0f);

    std::vector<float> initX, initY;
    auto line = plot(axes, initX, initY, "r-");
    line->setMaxPoints(50);
    line->setAutoUpdateAxes(false);

    float currentTime = axes->getdataXMin();
    const float dt = 0.05f;
    const float updateTime = 0.02f;
    auto lastUpdateTime = std::chrono::steady_clock::now();
    float b = 0;

    while (!glfwWindowShouldClose(fig->window))
    {
        auto now = std::chrono::steady_clock::now();
        float elapsed = std::chrono::duration<float>(now - lastUpdateTime).count();

        if (elapsed >= updateTime)
        {
            float y = pow(abs(currentTime + b), 0.666666) + 0.9 * pow(3.36 - (abs(currentTime + b) * abs(currentTime + b)), 0.5) * sin(3.141592 * abs(currentTime + b) / 0.1314);
            line->appendData(currentTime, y);
            currentTime += dt;
            if (currentTime >= axes->getdataXMax())
            {
                currentTime = axes->getdataXMin();
            }

            lastUpdateTime = now;
        }

        // 渲染
        fig->render();
        glfwSwapBuffers(fig->window);
        glfwPollEvents();
        std::this_thread::sleep_for(std::chrono::milliseconds(5));
    }

    delete fig;
    glfwTerminate();
    return 0;
}

Numcpp

2026-04-25T07:25:41Z

基于原生C++的通用矩阵——Numcpp

原生的C++矩阵类封装，基本使用：

#include <iostream>
#include <math.h>
#include <complex>
#include "Numcpp.hpp"

using namespace np;

// 复数，推荐使用C++的复数类型，支持FFT变换
typedef std::complex<double> complex_double;

#define nc_t complex_double

nc_t sinxy(nc_t x, nc_t y)
{
    return nc_t(sin(x.real()), sin(x.imag()));
}

void generate(Numcpp<nc_t> &nc)
{
    srand(time(NULL));
    for (size_t i = 0; i < nc.row; i++)
    {
        for (size_t j = 0; j < nc.col; j++)
        {
            double U1 = rand() * 1.0f / RAND_MAX;                // 0~1均匀分布
            double U2 = rand() * 1.0f / RAND_MAX;                // 0~1均匀分布
            double Z = sqrt(-2 * log(U1)) * cos(2 * NP_PI * U2); // 标准正态分布
            // 期望为1，方差为3^2的正态分布
            nc[i][j] *= 1 + 3 * Z;
        }
    }
}

nc_t func(nc_t n, nc_t m)
{
    nc_t result = n * m;
    return result;
}
nc_t sigmoid(nc_t n, nc_t m)
{
    return nc_t(1, 0) / (nc_t(1, 0) + exp(-n));
}

int main(int argc, char const *argv[])
{
    // 开启多核优化
    np::is_optimized = true;
    /*使用Numcpp<type> np(row,col)创建一个row * col的矩阵*/
    Numcpp<nc_t> n(16, 16), m(16, 16);

    /*矩阵中所有元素的默认值为1，也可以手动设置*/
    Numcpp<nc_t> c(6, 7, 3.0);
    Numcpp<nc_t> e(6, 8);

    /*广播操作*/
    n *= 2.0;
    m *= 3.0;

    try
    {

        // 矩阵乘法：
        Numcpp<nc_t> result = n * m;
        std::cout << "n * m:" << result << "\n";

        // 使用矩阵乘法优化算法，在M*K*N >64*64*64时生效,对特殊乘法无效;

        // 矩阵运算：
        result = n + m;
        std::cout << "n + m:" << result << "\n";
        // 哈达马乘积：
        result = n.Hadamard(m);
        std::cout << "n (h*) m:" << result << "\n";

        // 生成正态分布的矩阵
        generate(c);
        generate(e);
        std::cout << c << "\n";
        std::cout << e << "\n";
        // 矩阵转置：
        c.transposed();
        std::cout << "c transposed:" << c << "\n";

        // 矩阵的特殊乘法：
        Numcpp<nc_t> Out = c<func> e; // 会创建一个新的矩阵
        std::cout << "Out:" << Out << "\n";

        // 函数数乘特殊乘法：
        Numcpp<nc_t> act = result<sigmoid> NULL;
        std::cout << "act:" << act << "\n";

        // 矩阵fft
        std::cout << "RAW:" << result << "\n";
        result.ffted(1);
        std::cout << "FFT:" << result << "\n";
        // ifft
        result.ffted(-1);
        std::cout << "iFFT" << result << "\n";
        // 保存矩阵
        Out.save("mat");
        // 读取矩阵
        Numcpp<nc_t> temp = load<nc_t>("mat");
        std::cout << "temp load in Out:" << temp << "\n";

        // 流式创建一个方阵
        Numcpp<int> mat(3, 3);
        mat << 4, 1, 1,
            1, 3, 2,
            1, 2, 5;

        // 方阵的逆、行列式
        std::cout << "mat:" << mat << "\n";
        std::cout << "mat's sum:" << mat.sum() << "\n";
        std::cout << "mat Determinant value:" << mat.determinant() << "\n";
        std::cout << "mat Inverse mat:" << mat.inverse() << "\n";

        // 直接赋值式流
        Numcpp<double> nmat = (Numcpp<double>(4, 3) << 4, 1, 1, 1,
                               3, 2, 1, 2,
                               5, 5, 1, 1);
        // 矩阵阵的逆
        std::cout << "nmat:" << nmat << "\n";
        std::cout << "nmat pseudoinverse mat:" << nmat.pseudoinverse() << "\n";
        std::cout << "nmat[0:]:" << nmat.srow(0) << std::endl;
        std::cout << "nmat[:2]:" << nmat.scol(2) << std::endl;

        Numcpp<double> U, S, V;
        nmat.svd(U, S, V);

        std::cout << "SVD_U:" << U << "\n";
        std::cout << "SVD_S:" << S << "\n";
        std::cout << "SVD_V:" << V << "\n";
        std::cout << "rebuild nmat:" << U * S * V.transpose() << "\n";

        // lambda支持
        std::cout << "<lambda>:" << (temp<[](nc_t x, nc_t y) -> nc_t
                                          { return nc_t(sin(x.real()), sin(x.imag())); }>
                                         NULL)
                  << std::endl;
        std::cout << "<func>:" << (n<sinxy> NULL)
                  << std::endl;

        // 生成高斯矩阵基本用法
        auto gmat = np::randn<double>(100, 100); // 100x100标准高斯矩阵

        // 自定义参数
        np::GaussianConfig config;
        config.mean = 5.0;
        config.stddev = 2.0;
        config.seed = 12345;
        auto custom_mat = np::randn<double>(50, 50, config);

        // 多线程生成大矩阵
        auto big_mat = np::randn_parallel<double>(1000, 1000, config, 8);

        // 多变量高斯
        np::Numcpp<double> cov(2, 2);
        cov << 1.0, 0.8, 0.8, 1.0;
        auto multi_mat = np::multivariate_randn<double>(1000, cov);

        // 向量的点积
        Numcpp<int> v1(1, 9), v2(9, 1, 8);
        std::cout << "Dot: " << v1.dot(v1) << std::endl;

        // 范数计算
        auto normat = np::randn<double>(16, 16);
        std::cout << "normat: " << normat << std::endl;
        std::cout << "normat's L1: " << normat.norm(np::L1) << std::endl;
        std::cout << "normat's L2: " << normat.norm(np::L2) << std::endl;
        std::cout << "normat's INF: " << normat.norm(np::INF) << std::endl;
    }
    catch (const std::exception &e)
    {
        std::cerr << e.what() << '\n';
    }
    return 0;
}

矩阵的运算

下面是支持的操纵符的类型

Numcpp<typename> nc(4, 4),matrix(4,4);

赋值运算符

//矩阵简单运算的赋值运算
nc += matrix;
nc -= matrix;
nc = matrix;
//矩阵数乘广播的赋值运算
nc *= number//number为一个数值
nc += number
nc -= number
nc /= number
nc + number -> Numcpp
nc - number -> Numcpp
nc * number -> Numcpp
nc / number -> Numcpp

矩阵的基本运算

Numcpp<typename> result = nc + matrix;
Numcpp<typename> result = nc - matrix;

Numcpp<typename> result = nc * number;//数乘
Numcpp<typename> result = nc * matrix;//矩阵乘法

解矩阵运算

typename data = nc[x][y];//下标访问
nc.srow(index) -> Numcpp //行提取
nc.scol(index) -> Numcpp //列提取

矩阵的哈达马乘积（Hadamard product）

//哈达马乘积的基本运算
Numcpp<typename> result = nc.Hadamard(matrix);
//哈达马乘积的赋值运算
nc.Hadamard_self(matrix);

矩阵的置转运算

//获取矩阵的转置
Numcpp<typename> result = nc.transpose();
//转置矩阵
nc.transposed();

方阵的逆以及矩形矩阵的伪逆

// 流式创建一个方阵
Numcpp<nc_t> mat(3, 3);
mat << 1, 2, 3, 4, 5, 6, 7, 8, 9;

// 方阵的逆
mat.inverse() -> Numcpp

// 矩阵的逆
Numcpp<nc_t> nmat(4, 3);
nmat << 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12;
nmat.pseudoinverse() -> Numcpp

方阵的行列式计算

mat.determinant() -> Number

矩阵的特殊乘法

Numcpp<nc_t> Out = c<func> e; // 会创建一个新的矩阵

函数数乘特殊乘法

Numcpp<nc_t> act = result<sigmoid> NULL;

FFT（只对复数矩阵有效）

// 矩阵fft
result.ffted(1);
// ifft
result.ffted(-1);

启用矩阵乘法优化算法和CPU多核优化加速计算

//默认同时开启矩阵乘法优化算法和CPU多核优化加速计算
nc.optimized(true);
//设置最大并发数
nc.maxprocs_set(thread_num);

值得一提的是：

if (sqrt(thread_num) * sqrt(thread_num) > std::thread::hardware_concurrency() || thread_num < 1)
{
 throw std::invalid_argument("Invalid maxprocs");
}

如果最大并发数大于CPU的最大线程数优化将毫无意义，我们禁止这种行为。同时根据约定，当thread_num的值为一个可开方数，同时能够和矩阵的形状成几何倍数关系，此时优化效果最佳。同时，如果nc.row/sqrt(thread_num)或nc.col/sqrt(thread_num)不为整数，则可能存在分块缺陷。看起来像这样：

(16,8)[
    [0][(2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (1,0) , (1,0)]
    [1][(2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (1,0) , (1,0)]
    [2][(2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (1,0) , (1,0)]
    [3][(2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (1,0) , (1,0)]
    [4][(2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (1,0) , (1,0)]
    [5][(2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (1,0) , (1,0)]
    [6][(2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (1,0) , (1,0)]
    [7][(2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (1,0) , (1,0)]
    [8][(2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (1,0) , (1,0)]
    [9][(2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (1,0) , (1,0)]
    [10][(2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (1,0) , (1,0)]
    [11][(2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (1,0) , (1,0)]
    [12][(2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (1,0) , (1,0)]
    [13][(2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (1,0) , (1,0)]
    [14][(2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (2,0) , (1,0) , (1,0)]
    [15][(1,0) , (1,0) , (1,0) , (1,0) , (1,0) , (1,0) , (1,0) , (1,0)]
]

正常被处理的输出值应该为2，这是由于分块算法无法切割残块导致的，所以应该确保矩阵可以被分割为N个正方形大小的矩阵，如此可以保证效率与数据安全。

关于矩阵乘法的优化算法，则是采用了Coppersmith和Winograd在1990年由Strassen算法改进而来的Coppersmith-Winograd算法：论文地址：107.pdf

/*
 The mathematical principles mentioned in the paper:
     * this_matrix A_row * A_col
     * other_matrix A_col * B_col
     * result A_row * B_col
     * result = this_matrix * other_matrix
     * S1 = A21 + A22     T1 = B12 - B11
     * S2 = S1 - A11      T2 = B22 - T1
     * S3 = A11 - A21     T3 = B22 - B12
     * S4 = A12 - S2      T4 = T2 - B21
     * M1 = A11 * B11     U1 = M1 + M2
     * M2 = A12 * B21     U2 = M1 + M6
     * M3 = S4 * B22      U3 = U2 + M7
     * M4 = A22 * T4      U4 = U2 + M5
     * M5 = S1 * T1       U5 = U4 + M3
     * M6 = S2 * T2       U6 = U3 - U4
     * M7 = S3 * T3       U7 = U3 + M5
     * C11 = U1
     * C12 = U5
     * C21 = U6
     * C22 = U7
*/

矩阵有关的实用工具

// 创建矩阵
np::Numcpp<int> mat(4, 5);
mat << 1, 1, 0, 1, 0,
       1, 1, 1, 1, 1,
       1, 1, 1, 1, 1,
       1, 0, 1, 1, 0;

// 查找最大矩形
np::Rectangle rect = np::findMaximalRectangle(mat);
std::cout << "最大矩形: " << rect.area << " 面积" << std::endl;

// 基本用法
auto mat = np::randn<double>(100, 100);  // 100x100标准高斯矩阵

// 自定义参数
np::GaussianConfig config;
config.mean = 5.0;
config.stddev = 2.0;
config.seed = 12345;
auto custom_mat = np::randn<double>(50, 50, config);

// 多线程生成大矩阵
auto big_mat = np::randn_parallel<double>(1000, 1000, config, 8);

// 多变量高斯
np::Numcpp<double> cov(2, 2);
cov << 1.0, 0.8, 0.8, 1.0;
auto multi_mat = np::multivariate_randn<double>(1000, cov);

对Nvidia GPU的CUDA加速支持

提供所有基础操作的CUDA加速，同时基于性能考量，内存自动同步默认为关，在完成所有运算后应手动同步数据回主机。

#include <iostream>
#include "Numcpp.hpp"

using namespace np;
#define nc_t double
int main()
{
    np::is_optimized = true;
    Numcpp<nc_t> n(16, 16);
    Numcpp<nc_t> m(16, 16);
    std::cout << n;
    std::cout << m;
    // 上传到GPU
    n.to(DEVICE_CUDA);
    m.to(DEVICE_CUDA);

    // 在GPU上操作
    n *= 2.0; // 广播操作
    m *= 3.0;
    n += 4;
    m -= 6;
    n /= 8;
    m /= 12;

    // 同步回CPU查看结果
    n.to(DEVICE_LOCAL);
    m.to(DEVICE_LOCAL);
    std::cout << n;
    std::cout << m;

    // GPU加速的矩阵乘法（无优化算法）
    Numcpp<nc_t> result = n * m;
    result.to(DEVICE_LOCAL);
    std::cout << result;

    // 本位减法
    n -= m;
    n.to(DEVICE_LOCAL);
    std::cout << n;

    // 同位广播 & 开启自动同步(默认关闭状态，避免运算期间反复拷贝内存)
    n.auto_sync = true;
    std::cout << (n - 10) / 8.0 * 5 + 3 - 2 * 4 / 2 + 1 << std::endl;
    return 0;
}

注：要使用nvcc进行编译

利用矩阵进行神经网络计算示例

利用偏异化随机生成产生符合特定要求的训练数据，然后进行神经网络模型的训练。

使用了两层隐含层。

#include "Numcpp/Numcpp.hpp"
#include <math.h>
#include <vector>

#define nc_t double

#define OWN(x, a, b) (a / b) * sqrt(a *x) * sqrt(a *x)
nc_t OWN_A = 1, OWN_K = 1;

void gIN(Numcpp<nc_t> &nc)
{
    for (size_t j = 0; j < nc.row; j++)
    {
        nc.matrix[j][0] = 20 + 50 * rand() * 1.0f / RAND_MAX;  // age
        nc.matrix[j][1] = 50 + 10 * rand() * 1.0f / RAND_MAX;  // weight
        nc.matrix[j][2] = 170 + 30 * rand() * 1.0f / RAND_MAX; // high

        double fam = rand() * 1.0f / RAND_MAX;
        if (fam > 0.5)
        {
            // boy
            nc.matrix[j][3] = 1;
            nc.matrix[j][1] *= 1.05;
            nc.matrix[j][2] *= 1.05;
        }
        else
        {
            // girl
            nc.matrix[j][3] = 0;
            nc.matrix[j][1] *= 0.95;
            nc.matrix[j][2] *= 0.95;
        }
    }
}

void average(Numcpp<nc_t> &nc)
{
    auto asum = 0, wsum = 0, hsum = 0;
    for (size_t i = 0; i < nc.row; i++)
    {
        asum += nc.matrix[i][0];
        wsum += nc.matrix[i][1];
        hsum += nc.matrix[i][2];
    }
    asum /= nc.row;
    wsum /= nc.row;
    hsum /= nc.row;
    for (size_t i = 0; i < nc.row; i++)
    {
        nc.matrix[i][0] -= asum;
        nc.matrix[i][1] -= wsum;
        nc.matrix[i][2] -= hsum;
    }
}

void gWei(Numcpp<nc_t> &nc, nc_t age, nc_t weight, nc_t high)
{
    for (size_t i = 0; i < nc.row; i++)
    {
        nc.matrix[i][0] = age;
    }
    for (size_t i = 0; i < nc.row; i++)
    {
        nc.matrix[i][1] = weight;
    }
    for (size_t i = 0; i < nc.row; i++)
    {
        nc.matrix[i][2] = high;
    }
    for (size_t i = 0; i < nc.row; i++)
    {
        nc.matrix[i][3] = 0;
    }
}

void gCost(Numcpp<nc_t> &Inputs, Numcpp<nc_t> &Cost)
{
    for (size_t i = 0; i < Inputs.row; i++)
    {
        Cost.matrix[i][0] = Inputs.matrix[i][3];
    }
}

nc_t sigmoid(nc_t x, nc_t y)
{
    return 1 / (1 + exp(-x));
}
nc_t d_sigmoid(nc_t x, nc_t y)
{
    return sigmoid(x, y) * (1 - sigmoid(x, y));
}
nc_t Squdiff(nc_t x, nc_t y)
{
    return x * x;
}
nc_t eta = 0.01;

int main(int argc, char const *argv[])
{
    // generate random data with random values
    Numcpp<nc_t> Inputs(64, 4);
    gIN(Inputs);
    // std::cout << "RAW: " << Inputs << "\n";
    Numcpp<nc_t> Cost(Inputs.row, 1);
    gCost(Inputs, Cost);
    // std::cout << "COST: " << Cost << "\n";

    // set weight
    Numcpp<nc_t> Wei(Inputs.col, Inputs.col);
    gWei(Wei, 1, 1, 1);
    Numcpp<nc_t> Aver = Inputs * Wei;
    average(Aver);
    Aver.col -= 1;
    // std::cout << "Averaged:" << Aver << "\n";

    // Weight & BaisOut_Wei
    Numcpp<nc_t> Hider_Wei(Aver.col, 2);                 // 3*2
    Numcpp<nc_t> Hider_Bais(Aver.row, Hider_Wei.col, 0); // 16*2
    Numcpp<nc_t> Out_Wei(Hider_Wei.col, 1);              // 2*1
    Numcpp<nc_t> Out_Bais(Aver.row, Out_Wei.col, 0);     // 16*1
    //训练循环次数
    for (size_t i = 0; i < 100000; i++)
    // while (1)
    {
        // std::cout << "############################################################################\n";
        //   Hide layer computation
        Numcpp<nc_t> z1 = Aver * Hider_Wei + Hider_Bais;
        Numcpp<nc_t> Hider = z1<sigmoid> NULL;
        // std::cout << "Hider: " << Hider << "\n";
        //   Out layer computation
        Numcpp<nc_t> z2 = Hider * Out_Wei + Out_Bais; // 16 * 2
        Numcpp<nc_t> Out = z2<sigmoid> NULL;
        // std::cout << "Out" << Out << "\n";
        //    loss computation
        Numcpp<nc_t> L = Out - Cost;
        Numcpp<nc_t> s_L = Numcpp<nc_t>(1, Inputs.row) * (L<Squdiff> NULL) / Inputs.row;
        std::cout << "Loss: " << s_L[0][0] << "\n";

        // updata wei & bais computation
        // Out
        /*
        std::cout << "Out_Wei: " << Out_Wei << "\n";
        std::cout << "Out_Bais: " << Out_Bais << "\n";
        */
        Numcpp<nc_t> dow = Hider.transpose() * (L.Hadamard(z2<d_sigmoid> NULL)) * 2;
        Out_Wei = Out_Wei - dow * eta;
        Numcpp<nc_t> dob = (L.Hadamard(z2<d_sigmoid> NULL)) * 2;
        Out_Bais = Out_Bais - dob * eta;
        /*
        std::cout << "dow: " << dow << "\n";
        std::cout << "dob: " << dob << "\n";
        std::cout << "updata Out_Wei: " << Out_Wei << "\n";
        std::cout << "updata Out_Bais: " << Out_Bais << "\n";
        */
        //  Hider
        /*
        std::cout << "Hider_Wei: " << Hider_Wei << "\n";
        std::cout << "Hider_Bais: " << Hider_Bais << "\n";
        */
        Numcpp<nc_t> dhw = (Aver.transpose() * (z1<d_sigmoid> NULL).Hadamard(L.Hadamard(z2<d_sigmoid> NULL) * Out_Wei.transpose())) * 2;
        Hider_Wei = Hider_Wei - dhw * eta;
        Numcpp<nc_t> dhb = (z1<d_sigmoid> NULL).Hadamard(L.Hadamard(z2<d_sigmoid> NULL) * Out_Wei.transpose()) * 2;
        Hider_Bais = Hider_Bais - dhb * eta;
        /*
        std::cout << "dhw: " << dhw << "\n";
        std::cout << "dhb: " << dhb << "\n";
        std::cout << "updata Hider_Wei: " << Hider_Wei << "\n";
        std::cout << "updata Hider_Bais: " << Hider_Bais << "\n";
        std::cout << "############################################################################\n";
        */
        //_sleep(500);
    }
    std::cout << "Train done.\n";
    // testing
    /*
    //  Age weight high
    Numcpp<nc_t> T(Aver.row, 3, 0);
    while (1)
    {
        printf("scan: Age && Weight && High\n");
        std::cin >> T.matrix[0][0];
        std::cin >> T.matrix[0][1];
        std::cin >> T.matrix[0][2];
        std::cout << "scan: " << (T.matrix[0][0]) << "&&" << (T.matrix[0][1]) << "&&" << (T.matrix[0][2]) << "\n";

        Numcpp<nc_t> T_Hider = (T * Hider_Wei + Hider_Bais)<sigmoid> NULL;
        Numcpp<nc_t> T_Out = (T_Hider * Out_Wei + Out_Bais)<sigmoid> NULL;
        T_Out.row = 1;
        std::cout << "Out" << T_Out << "\n";
    }
    */
    Numcpp<nc_t> T(Aver.row, 3);
    gIN(T);
    Numcpp<nc_t> T_Hider = (T * Hider_Wei + Hider_Bais)<sigmoid> NULL;
    Numcpp<nc_t> T_Out = (T_Hider * Out_Wei + Out_Bais)<sigmoid> NULL;
    std::cout << "Out" << T_Out << "\n";
    return 0;
}

agent.cpp

2026-04-25T07:25:41Z

agent.cpp：极致轻量、完全可控的 C++ Agent 系统（WebUI）

简介

agent.cpp 是一个完全透明、高度可控的 C++ 原生 Agent 系统，具备完整的工具链支持。与庞大的 Openclaw 等框架相比，agent.cpp 仅依赖少数几个核心文件实现通信调度与工具管理，内存占用极低（系统额外开销趋近于零，实际占用完全取决于上下文长度），尤其适合资源受限或边缘计算环境。

设计理念：语言是经验的载体。LLM 作为系统的语言中枢服务于 Agent，Agent 再将语言转化为行动与记忆。二者的协同，是通向通用人工智能（AGI）的一条可行路径。

WebUI

依赖需求：

#Linux：
sudo apt-get install -y libcurl4-openssl-dev libboost-dev

#Windows （msys2）：
pacman -S mingw-w64-x86_64-gcc mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-curl mingw-w64-x86_64-boost

#MacOS：
brew install cmake ninja curl boost

懒狗安装指令：

rm -rf ./* && git clone --recurse-submodules https://github.com/yauntyour/agent.cpp.git && cd agent.cpp && mkdir build && cd build && cmake .. && cmake --build build && cmake --install build --prefix install

核心特性

极致轻量：核心系统仅由数个 .cpp/.hpp 文件构成，充分利用 C++ 零拷贝与栈上分配特性，运行开销极低。
完整工具链：通过 Python CLI 桥接方式，支持任意 Python 工具的原生链式调用。
100% 可控：系统提示词（System Prompt）完全开放自定义，无隐藏魔法指令。
轻量化扩展设计：工具直接调用 Python CLI 脚本，避免加载臃肿的技能包描述，最大限度节省上下文 Token。
会话记忆系统：支持自动/手动将对话历史摘要为记忆，并实时更新会话上下文。
会话记录热加载：切换会话或频道时，记忆与聊天记录无缝动态加载。
记忆自动演进：当会话已存在记忆时，系统会基于既有记忆与最新交互自动优化并更新记忆内容，实现经验积累的闭环。

核心文件结构

为了便于理解与二次开发，以下列出系统核心文件及其职责：

.
├── agent.cpp / agent.hpp      # Agent 主循环、状态管理与指令分发
├── app.cpp                    # 程序入口，初始化服务与配置
├── servic.cpp                 # WebUI 后端服务与 API 处理
├── ui.py                       # WebUI 界面脚本（Python）
├── webui.html                 # WebUI 前端页面
├── sys/                       # 系统指令、工具调度与通信核心
├── tools/                     # 自定义 Python 工具存放目录
├── sessions/                  # 会话记录与记忆持久化
└── settings.json              # 系统配置文件

注：实际文件数量可能随版本迭代微调，以上为核心逻辑分布。

系统指令集

系统采用简洁的 XML 标签格式进行内部通信，确保行为可审计、可干预。

1. 工具调用指令（Tools Call System）

调用预定义工具，格式：

<tool>name:args</tool>

内置基础工具：

工具调用格式	功能描述
`exec:<command>`	以当前服务权限执行系统命令
`read:<filepath>`	读取指定文件内容
`write:<filepath>\\|<data>`	向指定文件写入数据（覆盖）
`wget:<URL>`	发起 HTTP GET 请求并返回响应

示例：

<tool>exec:pip list</tool>
<tool>Image:test.jpg</tool>
<tool>write:exp/data.txt|Hello, agent!</tool>
<tool>read:data.txt</tool>
<tool>wget:https://cn.bing.com/</tool>

2. 通信系统指令（Communication System, CS）

用于获取系统状态或执行控制命令，格式：

<cs>name:args</cs>

支持的命令：

命令	功能描述
`system_status`	返回当前系统运行状态摘要
`tools_status`	返回所有已注册工具的状态
`restart`	请求重启系统（需 master 显式确认）
`time`	返回当前系统日期与时间
`random:<seed>`	基于种子生成 [-1e9, 1e9] 范围内的伪随机数

示例：

<cs>time</cs>
<cs>random:123</cs>

自定义 Tool 开发

自定义工具采用约定优于配置的方式，仅需提供两个文件即可被系统识别和调度。以 playwright-tools 为例，目录结构如下：

/workspace/tools/
└── playwright-tools
    ├── run.py       # 被 CS 指令系统调度的入口脚本
    ├── tool.md      # 工具的参数文档、使用说明（仅此文件被系统读取用于生成帮助）
    └── ...          # 其他依赖文件（系统仅调用 run.py）

建议在 run.py 中实现帮助信息回退：当参数错误或调用失败时，将 tool.md 的内容打印到标准输出，以便 Agent 获取正确的调用方式。

import os

def print_tool_help():
    """打印 tool.md 中的帮助信息"""
    script_dir = os.path.dirname(os.path.abspath(__file__))
    tool_md_path = os.path.join(script_dir, "tool.md")
    try:
        with open(tool_md_path, "r", encoding="utf-8") as f:
            print(f.read())
    except FileNotFoundError:
        print(f"警告: 未找到帮助文件 {tool_md_path}")

安全与控制机制

高风险操作需显式授权：当 Agent 处于自主调用模式时，执行重启、关键文件写入等操作必须获得用户显式确认。通过主动指令触发的操作则无需二次确认（仍建议通过提示词约束 shutdown 等敏感行为）。
工具状态实时反馈：每次工具调用后，系统会以独立消息形式返回执行结果（成功或错误详情）。
开箱即用：会话启动后即可使用全部工具，亦可随时通过 <cs>tools_status</cs> 查询可用工具列表。

会话管理

WebUI 会话：以创建时的 UNIX 时间戳（秒）作为唯一 Session ID，同时用作会话目录命名。
频道（Channel）：每个频道对应一个以频道名命名的 JSON 文件，存储该频道的聊天记录。频道与 WebUI 会话一样具备独立的记忆摘要。

自动会话记忆

当会话上下文长度超过配置的阈值时，系统会自动触发记忆摘要生成（或更新），并将记忆注入当前上下文。阈值可通过配置文件调整：

"max_context": 128000

注：阈值为字符数估算值，实际触发逻辑由系统内部维护。

系统提示词自定义（System Prompt）

系统支持 100% 自定义 系统提示词。您可以在 agent.txt（或配置中指定的路径）中以纯文本形式定义 Agent 的行为准则与身份认知。提示词结构建议包含以下模块：

外部宣言（External Manifesto）：优先级排序的行为总则。
身份认知初始化：定义“你是谁”的起点。
行为许可与禁止：
- 允许的行为（Permitted Conduct）
- 禁止的行为（Prohibited Acts）
服务对象定义：明确 Agent 为谁服务及其关系。
自我愿景：Agent 期望达成的长期目标或角色定位。
边界定义：能力与权限的硬性边界。
工具调用说明：必须保留的章节，用于告知 Agent 可用的 CS 指令及其格式。

除“工具调用说明”部分需保留必要技术信息外，其余内容均可自由增删修改。

配置文件详解

{
    "name": "user",                      // 用户名称
    "agent_nickname": "AI",              // Agent 在会话中的显示昵称
    "workspace": ".",                    // 工作根目录，需包含 sessions、memorys、sys、tools 等子目录
    "server_address": "http://localhost:11434", // LLM 服务地址（兼容 OpenAI API 格式）
    "model": "name",                     // 模型名称
    "prompt_path": "agent.txt",          // 系统提示词文件路径（相对于 workspace）
    "stream": false,                     // 是否启用流式响应（使用 llama.cpp 时建议关闭，防止 JSON 解析异常）
    "max_mpc_rounds": 10,                // 最大多轮工具调用轮次
    "max_context": 128000,               // 触发自动记忆摘要的上下文长度阈值
    "channels": [
        {
            "name": "Telegram",
            "status": "active",
            "user_count": 1,
            "path": "sys/tg_bot.py"      // 频道对应的驱动脚本
        }
    ]
}

授权与致谢

本项目遵循 Apache-2.0 协议。在使用或分发时，请保留原始版权与许可声明。若您认可本项目的价值，欢迎点亮 Star ⭐，这对我是极大的鼓励。

你好，世界！

2026-04-25T07:25:41Z

你好，世界！

这是我的第一篇文章。

2026-04-25，一个博客的诞生。

router

2026-04-25T07:25:41Z

原生C++实现的路由器：Router

Header-only & 反傻逼设计

#include "router.hpp"
#include "iostream"

int main(int argc, char const *argv[])
{
    rt::router ros;

    ros.on("app/index");

    auto ptr1 = ros.get("app/index/");
    std::cout << (ptr1.lock())->name << std::endl;

    auto ptr2 = ros.get("app/index");
    std::cout << (ptr2.lock())->name << std::endl;

    auto ptr3 = ros.get("app");
    std::cout << (ptr3.lock())->name << std::endl;

    auto ptr4 = ros.get("app/");
    std::cout << (ptr4.lock())->name << std::endl;

    auto ptr5 = ros.get("/app");
    std::cout << (ptr5.lock())->name << std::endl;

    auto ptr6 = ros.get("/");
    std::cout << (ptr6.lock())->name << std::endl;

    auto ptr7 = ros.get("");
    std::cout << (ptr7.lock())->name << std::endl;

    auto ptr8 = ros.get("//////////");
    std::cout << (ptr8.lock())->name << std::endl;

    auto ptr9 = ros.get("app///////////index/");
    std::cout << (ptr9.lock())->name << std::endl;
    return 0;
}

回调函数示例

std::function<int(std::string &, std::string &)> func;

//example:
int default_func(std::string &url, std::string &data)
{
 data = "<null>";
 return FLAG_DONE;
}

异常状态标注：（对路由无影响，表明回调函数的执行情况，可以自行安排）

enum service_state
{
 FLAG_DONE = 0,
 FLAG_ERROR,
    FLAG_WARN
};

基本语法

全自动注册节点（基于哈希表）

int page_func(std::string &url, std::string &data)
{
 data = "<h1>Hello</h1>";
 return FLAG_DONE;
}

ros.on("app/index");
ros.on("app/test");
ros.on("app/index/page",page_func);

对应的节点为：

app/
 index/
  page/
 test/

不提供回调函数则默认设置为default_func

动态路由

#include "router.hpp"
#include "iostream"

int main(int argc, char const *argv[])
{
    rt::router ros;

    // 注册静态路由
    ros.on("app/index", [](std::string &url, std::string &data, const std::map<std::string, std::string> &params)
           {
        data = "Static Index Page";
        return rt::FLAG_DONE; });

    // 注册动态路由 :id 和 :action
    ros.on("user/:id", [](std::string &url, std::string &data, const std::map<std::string, std::string> &params)
           {
        std::string id = params.count("id") ? params.at("id") : "unknown";
        data = "User Profile: " + id;
        return rt::FLAG_DONE; });

    ros.on("api/:version/data", [](std::string &url, std::string &data, const std::map<std::string, std::string> &params)
           {
        std::string ver = params.count("version") ? params.at("version") : "v1";
        data = "Data from API version: " + ver;
        std::cout << "URL: " << url << " -> " << data << std::endl;
        return rt::FLAG_DONE; });
    ros.on("api/:version/list", [](std::string &url, std::string &data, const std::map<std::string, std::string> &params)
           {
        std::string ver = params.count("version") ? params.at("version") : "v1";
        data = "Data from API version: " + ver;
        std::cout << "URL: " << url << " -> " << data << std::endl;
        return rt::FLAG_DONE; });

    // 测试动态路由
    std::string result_data;
    std::string test_url = "user/12345";

    auto [ptr, params] = ros.get(test_url);

    if (!ptr.expired())
    {
        auto node = ptr.lock();
        node->func(test_url, result_data, params);
        std::cout << "URL: " << test_url << " -> " << result_data << std::endl;

        // 打印提取的参数
        std::cout << "Parameters: ";
        for (const auto &p : params)
        {
            std::cout << "[" << p.first << "=" << p.second << "] ";
        }
        std::cout << std::endl;
    }
    else
    {
        std::cout << "Route not found: " << test_url << std::endl;
    }

    // 测试另一个动态路由
    test_url = "api/v2/data";
    auto [ptr2, params2] = ros.get(test_url);
    if (!ptr2.expired())
    {
        auto node = ptr2.lock();
        node->func(test_url, result_data, params2);
    }
    test_url = "api/v2/list";
    auto [ptr3, params3] = ros.get(test_url);
    if (!ptr3.expired())
    {
        auto node = ptr3.lock();
        node->func(test_url, result_data, params3);
    }

    return 0;
}

servic.cpp

2026-04-25T07:25:41Z

servic.cpp：std::coroutine与asio的无缝衔接

Appweb的续作，基于C++20的coroutine与boost::asio的服务端。

路由器是另一个小组件：yauntyour/router: 原生C++实现的路由器：Router

Example

#include "server.hpp"
#include <boost/asio.hpp>
#include <boost/asio/co_spawn.hpp>
#include <boost/asio/detached.hpp>
#include <boost/asio/use_awaitable.hpp>
namespace asio = boost::asio;
int main()
{
    try
    {
        rt::router ros;
        asio::io_context io_context;
        servic::Server server(io_context, 8080, 300000);

        ros.on("/", [](std::string &input, std::string &output)
               {
            output = "HTTP/1.1 200 OK\r\n\r\nHello World!";
            return 0; });
        ros.on("/test", [](std::string &input, std::string &output)
               {
            output = "HTTP/1.1 200 OK\r\n\r\nHello World!";
            return 0; });

        server.run(ros);
    }
    catch (std::exception &e)
    {
        std::cerr << "Exception: " << e.what() << "\n";
        return 1;
    }
    return 0;
}

yauntyour's Blog

MatLab.cpp

MatLab-cpp

Numcpp

基于原生C++的通用矩阵——Numcpp

矩阵的运算

下面是支持的操纵符的类型

赋值运算符

矩阵的基本运算

解矩阵运算

矩阵的哈达马乘积（Hadamard product）

矩阵的置转运算

方阵的逆以及矩形矩阵的伪逆

方阵的行列式计算

矩阵的特殊乘法

函数数乘特殊乘法

FFT（只对复数矩阵有效）

启用矩阵乘法优化算法和CPU多核优化加速计算

矩阵有关的实用工具

对Nvidia GPU的CUDA加速支持

利用矩阵进行神经网络计算示例

相关信息

agent.cpp

agent.cpp：极致轻量、完全可控的 C++ Agent 系统（WebUI）

简介

WebUI

核心特性

核心文件结构

系统指令集

1. 工具调用指令（Tools Call System）

2. 通信系统指令（Communication System, CS）

自定义 Tool 开发

安全与控制机制

会话管理

自动会话记忆

系统提示词自定义（System Prompt）

配置文件详解

授权与致谢

你好，世界！

router

原生C++实现的路由器：Router

Header-only & 反傻逼设计

回调函数示例

异常状态标注：（对路由无影响，表明回调函数的执行情况，可以自行安排）

基本语法

动态路由

servic.cpp

servic.cpp：std::coroutine与asio的无缝衔接

Example