test_utils.cpp

#include "utils.h"
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>

// 用于浮点数比较的辅助函数
bool is_close(double a, double b, double rtol = 1e-5, double atol = 1e-8) {
    return std::abs(a - b) <= (atol + rtol * std::abs(b));
}

// 用于向量比较的辅助函数
bool are_vectors_close(const std::vector<double> &a,
                       const std::vector<double> &b, double rtol = 1e-5,
                       double atol = 1e-8) {
    if (a.size() != b.size()) {
        return false;
    }

    for (size_t i = 0; i < a.size(); ++i) {
        if (!is_close(a[i], b[i], rtol, atol)) {
            return false;
        }
    }

    return true;
}

// 打印向量的辅助函数
void print_vector(const std::vector<double> &vec, const std::string &name) {
    std::cout << name << ": [";
    for (size_t i = 0; i < vec.size(); ++i) {
        std::cout << vec[i];
        if (i < vec.size() - 1) {
            std::cout << ", ";
        }
    }
    std::cout << "]" << std::endl;
}

// 测试单个函数的辅助宏
#define TEST_FUNCTION(func, ...)                                               \
    std::cout << "Testing " #func "... ";                                      \
    try {                                                                      \
        func(__VA_ARGS__);                                                     \
        std::cout << "PASS" << std::endl;                                      \
    } catch (const std::exception &e) {                                        \
        std::cout << "FAIL: " << e.what() << std::endl;                        \
    }

// 测试PDF函数
void test_pdf() {
    // 标准正态分布在0处的PDF应该约为0.3989
    double pdf_0 = utils::pdf(0.0, 0.0, 1.0);
    assert(is_close(pdf_0, 0.3989423));

    // 均值为5.0，标准差为2.0的正态分布在5.0处的PDF应该约为0.1995
    double pdf_5 = utils::pdf(5.0, 5.0, 2.0);
    assert(is_close(pdf_5, 0.1994711));

    // 测试向量版本
    std::vector<double> x = {-2.0, -1.0, 0.0, 1.0, 2.0};
    std::vector<double> expected = {0.0539909, 0.2419707, 0.3989423, 0.2419707,
                                    0.0539909};
    std::vector<double> result = utils::pdf_vec(x, 0.0, 1.0);
    assert(are_vectors_close(result, expected));
}

// 测试逆对数CDF函数
void test_invLogCDF() {
    std::cout << std::setprecision(64) << std::fixed;
    // 这个函数是对log(1-cdf(x))的近似，很难直接验证
    // 但我们可以测试一些边界情况
    double val1 = utils::invLogCDF(10.0, 0.0, 1.0); // 应该是一个很大的负数
    std::cout << val1 << std::endl;
    assert(val1 < -50.0);

    double val2 = utils::invLogCDF(-10.0, 0.0, 1.0); // 应该接近0
    std::cout << val2 << std::endl;
    assert(is_close(val2, 0.0, 0.1));
}

// 测试Sigmoid函数
void test_sigmoid() {
    // Sigmoid(0) = 0.5
    assert(is_close(utils::sigmoid(0.0), 0.5));

    // Sigmoid(很大的值) ≈ 1
    assert(is_close(utils::sigmoid(100.0), 1.0));

    // Sigmoid(很小的值) ≈ 0
    assert(is_close(utils::sigmoid(-100.0), 0.0));

    // 测试导数
    double sig_val = utils::sigmoid(1.5);
    double dsig_val = utils::dsigmoid(sig_val);
    assert(is_close(dsig_val, sig_val * (1.0 - sig_val)));

    // 测试向量版本
    std::vector<double> x = {-2.0, -1.0, 0.0, 1.0, 2.0};
    std::vector<double> result = utils::sigmoid_vec(x);
    std::vector<double> dresult = utils::dsigmoid_vec(result);

    for (size_t i = 0; i < x.size(); ++i) {
        double sig_i = 1.0 / (1.0 + std::exp(-x[i]));
        assert(is_close(result[i], sig_i));
        assert(is_close(dresult[i], sig_i * (1.0 - sig_i)));
    }
}

// 测试Tanh函数
void test_tanh() {
    // tanh(0) = 0
    assert(is_close(utils::tanh(0.0), 0.0));

    // tanh(很大的值) ≈ 1
    assert(is_close(utils::tanh(10.0), 1.0));

    // tanh(很小的值) ≈ -1
    assert(is_close(utils::tanh(-10.0), -1.0));

    // 测试导数
    double tanh_val = utils::tanh(1.5);
    double dtanh_val = utils::dtanh(tanh_val);
    assert(is_close(dtanh_val, 1.0 - tanh_val * tanh_val));

    // 测试向量版本
    std::vector<double> x = {-2.0, -1.0, 0.0, 1.0, 2.0};
    std::vector<double> result = utils::tanh_vec(x);
    std::vector<double> dresult = utils::dtanh_vec(result);

    for (size_t i = 0; i < x.size(); ++i) {
        double tanh_i = std::tanh(x[i]);
        assert(is_close(result[i], tanh_i));
        assert(is_close(dresult[i], 1.0 - tanh_i * tanh_i));
    }
}

// 测试Softmax函数
void test_softmax() {
    // 对于单个元素，应该返回1
    std::vector<double> x1 = {1.0};
    std::vector<double> res1 = utils::softmax(x1);
    assert(res1.size() == 1);
    assert(is_close(res1[0], 1.0));

    // 对于相同元素，应该返回均匀分布
    std::vector<double> x2 = {1.0, 1.0, 1.0};
    std::vector<double> res2 = utils::softmax(x2);
    assert(res2.size() == 3);
    assert(is_close(res2[0], 1.0 / 3.0));
    assert(is_close(res2[1], 1.0 / 3.0));
    assert(is_close(res2[2], 1.0 / 3.0));

    // 测试一般情况
    std::vector<double> x3 = {1.0, 2.0, 3.0};
    std::vector<double> res3 = utils::softmax(x3);
    assert(res3.size() == 3);

    // 和应该为1
    double sum = res3[0] + res3[1] + res3[2];
    assert(is_close(sum, 1.0));

    // 顺序应该保持 (res3[0] < res3[1] < res3[2])
    assert(res3[0] < res3[1]);
    assert(res3[1] < res3[2]);
}

// 测试ReLU函数
void test_relu() {
    // ReLU(负数) = 0
    assert(is_close(utils::ReLU(-1.0), 0.0));

    // ReLU(0) = 0
    assert(is_close(utils::ReLU(0.0), 0.0));

    // ReLU(正数) = 原值
    assert(is_close(utils::ReLU(1.5), 1.5));

    // 测试导数
    double drelu_neg = utils::dReLU(-1.0);
    double drelu_zero = utils::dReLU(0.0);
    double drelu_pos = utils::dReLU(1.5);

    assert(is_close(drelu_neg, 0.0));
    assert(is_close(drelu_zero, 0.0));
    assert(is_close(drelu_pos, 1.0));

    // 测试向量版本
    std::vector<double> x = {-2.0, -1.0, 0.0, 1.0, 2.0};
    std::vector<double> expected_relu = {0.0, 0.0, 0.0, 1.0, 2.0};
    std::vector<double> expected_drelu = {0.0, 0.0, 0.0, 1.0, 1.0};

    std::vector<double> result_relu = utils::ReLU_vec(x);
    std::vector<double> result_drelu = utils::dReLU_vec(x);

    assert(are_vectors_close(result_relu, expected_relu));
    assert(are_vectors_close(result_drelu, expected_drelu));
}

// 测试RollMean类
void test_rollmean() {
    utils::RollMean rm(3);

    // 测试初始化后的值
    double val1 = rm.apply(1.0);
    assert(is_close(val1, 1.0 / 3.0)); // (0 + 0 + 1) / 3

    double val2 = rm.apply(2.0);
    assert(is_close(val2, 1.0)); // (0 + 1 + 2) / 3

    double val3 = rm.apply(3.0);
    assert(is_close(val3, 2.0)); // (1 + 2 + 3) / 3

    // 测试循环行为
    double val4 = rm.apply(4.0);
    assert(is_close(val4, 3.0)); // (2 + 3 + 4) / 3

    double val5 = rm.apply(5.0);
    assert(is_close(val5, 4.0)); // (3 + 4 + 5) / 3
}

int main() {
    std::cout << "===== Testing utils functions =====" << std::endl;

    TEST_FUNCTION(test_pdf);
    TEST_FUNCTION(test_invLogCDF);
    TEST_FUNCTION(test_sigmoid);
    TEST_FUNCTION(test_tanh);
    TEST_FUNCTION(test_softmax);
    TEST_FUNCTION(test_relu);
    TEST_FUNCTION(test_rollmean);

    std::cout << "===== All tests completed =====" << std::endl;

    return 0;
}