utils.cpp

#include "utils.h"
#include <algorithm>
#include <cmath>
#include <numeric>
#include <stdexcept>

namespace utils {

// 数学常数
constexpr double PI = 3.14159265358979323846;
constexpr double SQRT_2PI = 2.5066282746310002;

double pdf(double x, double mu, double sigma) {
    // 正态分布概率密度函数
    double z = (x - mu) / sigma;
    return std::exp(-0.5 * z * z) / (SQRT_2PI * sigma);
}

double invLogCDF(double x, double mu, double sigma) {
    // 正态分布的逆对数累积分布函数
    double z = (x - mu) / sigma;

    return std::log(0.5) + std::log(boost::math::erfc(z / std::sqrt(2.0)));
}

double sigmoid(double x) {
    // Sigmoid激活函数
    return 1.0 / (1.0 + std::exp(-x));
}

double dsigmoid(double x) {
    // Sigmoid激活函数的导数 (x已经是sigmoid的输出)
    return x * (1.0 - x);
}

double tanh(double x) {
    // Tanh激活函数
    return std::tanh(x);
}

double dtanh(double x) {
    // Tanh激活函数的导数 (x已经是tanh的输出)
    return 1.0 - x * x;
}

std::vector<double> softmax(const std::vector<double> &x) {
    // Softmax激活函数
    if (x.empty()) {
        return {};
    }

    // 找到最大值，避免溢出
    double max_val = *std::max_element(x.begin(), x.end());

    // 计算exp(x-max)
    std::vector<double> exp_x(x.size());
    for (size_t i = 0; i < x.size(); ++i) {
        exp_x[i] = std::exp(x[i] - max_val);
    }

    // 计算和
    double sum_exp = std::accumulate(exp_x.begin(), exp_x.end(), 0.0);

    // 归一化
    for (double &val : exp_x) {
        val /= sum_exp;
    }

    return exp_x;
}

double ReLU(double x) {
    // ReLU激活函数
    return x > 0.0 ? x : 0.0;
}

double dReLU(double x) {
    // ReLU激活函数的导数
    return x > 0.0 ? 1.0 : 0.0;
}

// RollMean类实现
RollMean::RollMean(size_t k) : winsize(k), window(k, 0.0), pointer(0) {
    if (k == 0) {
        throw std::invalid_argument("Window size must be greater than 0");
    }
}

double RollMean::apply(double newval) {
    window[pointer] = newval;
    pointer = (pointer + 1) % winsize;

    // 计算平均值
    return std::accumulate(window.begin(), window.end(), 0.0) / winsize;
}

// 向量版本的函数实现

std::vector<double> pdf_vec(const std::vector<double> &x, double mu,
                            double sigma) {
    std::vector<double> result(x.size());
    for (size_t i = 0; i < x.size(); ++i) {
        result[i] = pdf(x[i], mu, sigma);
    }
    return result;
}

std::vector<double> invLogCDF_vec(const std::vector<double> &x, double mu,
                                  double sigma) {
    std::vector<double> result(x.size());
    for (size_t i = 0; i < x.size(); ++i) {
        result[i] = invLogCDF(x[i], mu, sigma);
    }
    return result;
}

std::vector<double> sigmoid_vec(const std::vector<double> &x) {
    std::vector<double> result(x.size());
    for (size_t i = 0; i < x.size(); ++i) {
        result[i] = sigmoid(x[i]);
    }
    return result;
}

std::vector<double> dsigmoid_vec(const std::vector<double> &x) {
    std::vector<double> result(x.size());
    for (size_t i = 0; i < x.size(); ++i) {
        result[i] = dsigmoid(x[i]);
    }
    return result;
}

std::vector<double> tanh_vec(const std::vector<double> &x) {
    std::vector<double> result(x.size());
    for (size_t i = 0; i < x.size(); ++i) {
        result[i] = tanh(x[i]);
    }
    return result;
}

std::vector<double> dtanh_vec(const std::vector<double> &x) {
    std::vector<double> result(x.size());
    for (size_t i = 0; i < x.size(); ++i) {
        result[i] = dtanh(x[i]);
    }
    return result;
}

std::vector<double> ReLU_vec(const std::vector<double> &x) {
    std::vector<double> result(x.size());
    for (size_t i = 0; i < x.size(); ++i) {
        result[i] = ReLU(x[i]);
    }
    return result;
}

std::vector<double> dReLU_vec(const std::vector<double> &x) {
    std::vector<double> result(x.size());
    for (size_t i = 0; i < x.size(); ++i) {
        result[i] = dReLU(x[i]);
    }
    return result;
}

} // namespace utils