【C语言标准库函数】取整与取余函数：ceil(), floor(), fmod(), 和 modf()

#include <math.h>
double ceil(double x);

function ceil(double x) {
    // 处理特殊值：NaN返回NaN，正无穷返回正无穷，负无穷返回负无穷
    if (x is NaN or x == +infinity) {
        return x;
    }
    if (x == -infinity) {
        return x;
    }
    
    // 提取x的整数部分（截断小数）
    int integer_part = (int)x;
    
    // 若x为正数且有小数部分，向上取整为integer_part + 1
    if (x > 0.0 && x > (double)integer_part) {
        return (double)(integer_part + 1);
    }
    // 若x为负数且有小数部分（此时x < integer_part，因整数部分是截断的），直接返回integer_part
    else if (x < 0.0 && x < (double)integer_part) {
        return (double)integer_part;
    }
    // 若x为整数，直接返回自身
    else {
        return x;
    }
}

#include <math.h>
double floor(double x);

function floor(double x) {
    // 处理特殊值
    if (x is NaN or x == -infinity) {
        return x;
    }
    if (x == +infinity) {
        return x;
    }
    
    // 提取整数部分（截断小数）
    int integer_part = (int)x;
    
    // 若x为正数且有小数部分，直接返回integer_part（向下取整）
    if (x > 0.0 && x > (double)integer_part) {
        return (double)integer_part;
    }
    // 若x为负数且有小数部分，向下取整为integer_part - 1
    else if (x < 0.0 && x < (double)integer_part) {
        return (double)(integer_part - 1);
    }
    // 整数直接返回
    else {
        return x;
    }
}

#include <math.h>
double fmod(double x, double y);

function fmod(double x, double y) {
    // 处理特殊情况：y为0或x为无穷/NaN，返回NaN
    if (y == 0.0 || x is NaN || y is NaN || x == +infinity || x == -infinity) {
        return NaN;
    }
    // 若x为0，返回0.0（符号与x一致）
    if (x == 0.0) {
        return x;
    }
    
    // 计算商的整数部分（向零方向取整）
    double quotient = x / y;
    int n = (int)quotient; // 截断小数，向零取整
    
    // 计算余数：x - n*y
    double remainder = x - n * y;
    
    // 确保余数绝对值小于y的绝对值（处理精度误差）
    while (fabs(remainder) >= fabs(y)) {
        remainder -= (remainder > 0) ? y : -y;
    }
    while (fabs(remainder) < 0) {
        remainder += (remainder > 0) ? y : -y;
    }
    
    return remainder;
}

#include <math.h>
double modf(double x, double *intpart);

function modf(double x, double *intpart) {
    // 处理特殊值：NaN返回NaN，无穷大返回0.0并将intpart设为无穷大
    if (x is NaN) {
        *intpart = NaN;
        return NaN;
    }
    if (x == +infinity) {
        *intpart = +infinity;
        return 0.0;
    }
    if (x == -infinity) {
        *intpart = -infinity;
        return 0.0;
    }
    
    // 提取整数部分（向零方向取整）
    double integer = (double)(int)x;
    
    // 计算小数部分：x - 整数部分
    double fractional = x - integer;
    
    // 处理精度误差：例如0.999999999999可能被识别为1.0
    if (fabs(fractional) >= 1.0) {
        integer += (fractional > 0) ? 1.0 : -1.0;
        fractional = x - integer;
    }
    
    // 传出整数部分，返回小数部分
    *intpart = integer;
    return fractional;
}

#include <stdio.h>
#include <math.h>
#include <stdlib.h>

int main() {
    double x, y;
    // 输入提示与数据读取
    printf("请输入一个浮点数x：");
    if (scanf("%lf", &x) != 1) {
        printf("输入错误！\n");
        return 1;
    }
    printf("请输入除数y（用于fmod计算）：");
    if (scanf("%lf", &y) != 1) {
        printf("输入错误！\n");
        return 1;
    }
    
    // 函数调用
    double ceil_result = ceil(x);
    double floor_result = floor(x);
    double fmod_result = fmod(x, y);
    double intpart, modf_result = modf(x, &intpart);
    
    // 结果输出（格式化）
    printf("\n===== 数值处理结果 =====\n");
    printf("1. ceil(x) 向上取整：%.6f\n", ceil_result);
    printf("2. floor(x) 向下取整：%.6f\n", floor_result);
    printf("3. fmod(x, y) 浮点数取余：%.6f\n", fmod_result);
    printf("4. modf(x) 拆分结果：整数部分=%.6f，小数部分=%.6f\n", intpart, modf_result);
    
    // 附加：验证modf拆分的正确性（两部分之和是否等于原数）
    double sum = intpart + modf_result;
    printf("\n附加验证：整数部分 + 小数部分 = %.6f（原数x=%.6f）\n", sum, x);
    printf("拆分正确性：%s\n", fabs(sum - x) < 1e-9 ? "正确" : "存在精度误差");
    
    return 0;
}

gcc -o num_process num_process.c -lm
./num_process

请输入一个浮点数x：123.456
请输入除数y（用于fmod计算）：10.0

===== 数值处理结果 =====
1. ceil(x) 向上取整：124.000000
2. floor(x) 向下取整：123.000000
3. fmod(x, y) 浮点数取余：3.456000
4. modf(x) 拆分结果：整数部分=123.000000，小数部分=0.456000

附加验证：整数部分 + 小数部分 = 123.456000（原数x=123.456000）
拆分正确性：正确

#include <math.h>
// 四舍五入函数，保留n位小数
double round_n(double x, int n) {
    double scale = pow(10, n);
    if (x > 0) {
        return floor(x * scale + 0.5) / scale;
    } else {
        return ceil(x * scale - 0.5) / scale;
    }
}

#include <time.h>
#include <math.h>
// 假设获取系统运行时间（单位：ms）
double get_system_time_ms() {
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return ts.tv_sec * 1000.0 + ts.tv_nsec / 1e6;
}

// 周期性任务检查：余数小于1ms则认为到达周期
int is_task_time(double period) {
    double now = get_system_time_ms();
    return fabs(fmod(now, period)) < 1.0;
}