【安全函数】sinh_s()、cosh_s()、tanh_s()实战

#include <math.h>
#include <errno.h>  // 依赖标准错误码定义

// 安全双曲正弦函数：计算x的双曲正弦值
// 参数：x - 输入自变量（double类型），result - 计算结果输出指针（需提前分配内存）
// 返回值：0表示计算成功，非0为错误码（对应errno定义）
int sinh_s(double x, double *result);

// 安全双曲余弦函数：计算x的双曲余弦值
int cosh_s(double x, double *result);

// 安全双曲正切函数：计算x的双曲正切值
int tanh_s(double x, double *result);

// 公共安全校验函数：返回0表示校验通过，非0为错误码
int safe_math_common_check(double x, double *result) {
    // 1. 校验输出指针有效性（核心安全点：避免NULL指针解引用）
    if (result == NULL) {
        return EINVAL;
    }
    // 2. 校验输入x是否为非法值（NaN或非数值）
    if (isnan(x) || isinf(x)) {
        return EINVAL;
    }
    // 3. 校验输出内存可写性（可选，需结合系统API实现）
    if (!is_memory_writable(result, sizeof(double))) {
        return ENOMEM;
    }
    return 0;
}

int sinh_s(double x, double *result) {
    // 步骤1：调用公共模块完成基础校验
    int err = safe_math_common_check(x, result);
    if (err != 0) {
        return err;  // 校验失败直接返回错误码
    }
    
    // 步骤2：边界范围校验（预判溢出，比标准函数更安全）
    const double MAX_SAFE_RANGE = 709.0;  // double类型eˣ最大不溢出值
    if (x > MAX_SAFE_RANGE || x < -MAX_SAFE_RANGE) {
        return ERANGE;  // 提前拦截溢出场景
    }
    
    // 步骤3：核心数值计算（与标准函数逻辑一致）
    double exp_x = exp(x);
    double exp_neg_x = exp(-x);
    *result = (exp_x - exp_neg_x) / 2.0;
    
    // 步骤4：结果闭环校验（应对极端场景的精度异常）
    if (isnan(*result) || isinf(*result)) {
        return ERANGE;
    }
    
    return 0;  // 计算成功
}

int cosh_s(double x, double *result) {
    // 步骤1：基础校验
    int err = safe_math_common_check(x, result);
    if (err != 0) {
        return err;
    }
    
    // 步骤2：边界范围校验（利用偶函数对称性，仅校验绝对值）
    const double MAX_SAFE_RANGE = 709.0;
    if (fabs(x) > MAX_SAFE_RANGE) {
        return ERANGE;
    }
    
    // 步骤3：核心计算（简化为绝对值计算，提升效率）
    double abs_x = fabs(x);
    double exp_abs_x = exp(abs_x);
    *result = (exp_abs_x + exp(-abs_x)) / 2.0;
    
    // 步骤4：结果校验（cosh(x)最小值为1，允许微小精度误差）
    if (*result < 1.0 - 1e-15) {
        return ERANGE;
    }
    
    return 0;
}

int tanh_s(double x, double *result) {
    // 步骤1：基础校验
    int err = safe_math_common_check(x, result);
    if (err != 0) {
        return err;
    }
    
    // 步骤2：极端值优化（无溢出风险，直接返回近似值）
    const double EXTREME_RANGE = 20.0;
    if (x > EXTREME_RANGE) {
        *result = 1.0 - 1e-15;  // 避免返回精确1.0，符合数学定义
        return 0;
    }
    if (x < -EXTREME_RANGE) {
        *result = -1.0 + 1e-15;
        return 0;
    }
    
    // 步骤3：核心计算（优化版，减少exp调用次数）
    double exp_2x = exp(2 * x);
    *result = (exp_2x - 1.0) / (exp_2x + 1.0);
    
    // 步骤4：结果校验（确保值域严格落在(-1,1)内）
    if (*result <= -1.0 || *result >= 1.0) {
        return ERANGE;
    }
    
    return 0;
}

#include "safe_math.h"  // 自定义安全数学库
#include "log.h"       // 日志模块
#include "robot.h"     // 机器人控制模块

// 机械臂悬链线轨迹计算：x为水平距离，返回y轴高度
int robot_trajectory_calc(double x, double *y) {
    double a = 0.8;  // 悬链线参数（与机械臂负载相关）
    double sinh_val;
    
    // 调用安全函数计算sinh(x/a)
    int err = sinh_s(x / a, &sinh_val);
    if (err != 0) {
        // 异常处理：记录日志+切换手动模式
        if (err == EINVAL) {
            log_error("轨迹计算参数无效：x=%.2f", x);
        } else if (err == ERANGE) {
            log_error("轨迹计算参数超出范围：x=%.2f", x);
        }
        robot_switch_manual();  // 切换手动模式
        return -1;
    }
    
    *y = a * sinh_val;  // 悬链线轨迹方程：y = a·sinh(x/a)
    return 0;
}

#include "safe_math.h"
#include "risk.h"      // 风控模块

// 收益率曲线拟合：t为时间周期（年），返回拟合收益率
int yield_curve_fit(double t, double *yield) {
    double cosh_val;
    
    // 计算cosh(0.12*t)（0.12为行业经验系数）
    int err = cosh_s(0.12 * t, &cosh_val);
    if (err != 0) {
        risk_flag_trigger(FLAG_YIELD_CALC_ERR);  // 触发风控预警
        log_error("收益率计算失败，错误码：%d", err);
        return -1;
    }
    
    // 收益率拟合公式（结合行业模型）
    *yield = 0.045 * cosh_val + 0.012;
    // 二次校验收益率合理性（0%-20%为正常范围）
    if (*yield < 0.0 || *yield > 0.2) {
        log_warn("收益率异常：%.2f%%", *yield * 100);
    }
    
    return 0;
}

#include "safe_math.h"
#include "orbit.h"     // 轨道控制模块

// 卫星轨道修正：delta_v为速度增量，返回修正量
int orbit_correction(double delta_v, double *correction) {
    double safe_val, std_val;
    
    // 安全函数计算
    int err = tanh_s(delta_v, &safe_val);
    if (err != 0) {
        orbit_emergency_nav();  // 触发备用导航
        log_fatal("轨道修正计算失败，错误码：%d", err);
        return -1;
    }
    
    // 冗余验证：标准函数计算（仅用于对比）
    std_val = tanh(delta_v);
    // 校验结果一致性（允许1e-10精度偏差）
    if (fabs(safe_val - std_val) > 1e-10) {
        log_warn("轨道修正结果不一致：安全函数=%.10f，标准函数=%.10f", safe_val, std_val);
    }
    
    *correction = safe_val * 1500.0;  // 修正量转换（单位：米）
    return 0;
}

// 错误用法：忽略返回值，异常无法感知
double result;
tanh_s(100.0, &result);  // 实际x=100超出优化范围，但未处理

// 正确用法：完整处理返回值
double result;
int err = tanh_s(100.0, &result);
if (err != 0) {
    // 针对性处理逻辑
    log_error("tanh_s计算失败：%d", err);
    return err;
}

// 错误码转换为统一描述
const char* safe_math_err_desc(int err) {
#ifdef OS_LITEOS
    switch (err) {
        case OS_ERR_SAFE_MATH_NULL: return "输出指针为NULL";
        case OS_ERR_SAFE_MATH_RANGE: return "参数超出范围";
        default: return "未知错误";
    }
#else
    switch (err) {
        case EINVAL: return "无效参数";
        case ERANGE: return "范围错误";
        default: return "未知错误";
    }
#endif
}

// 错误用法1：传入NULL指针
double *result = NULL;
sinh_s(5.0, result);  // 返回EINVAL

// 错误用法2：传入只读内存指针
const double result = 0.0;
sinh_s(5.0, &result);  // 返回ENOMEM

// 正确用法1：使用栈内存
double result_stack;
sinh_s(5.0, &result_stack);

// 正确用法2：使用动态内存
double *result_heap = malloc(sizeof(double));
if (result_heap != NULL) {
    sinh_s(5.0, result_heap);
    free(result_heap);
}

// 精度优化版sinh_s核心计算
long double exp_x = expl((long double)x);  // long double精度更高
long double exp_neg_x = expl(-(long double)x);
*result = (double)((exp_x - exp_neg_x) / 2.0L);

// 兼容老旧编译器的isnan实现
int my_isnan(double x) {
    return x != x;  // NaN的特性：自身不相等
}

// 兼容老旧编译器的isinf实现
int my_isinf(double x) {
    return (x > 0 && x == 1.0 / 0.0) || (x < 0 && x == -1.0 / 0.0);
}