【C语言标准库函数】浮点数分解与构造: frexp() 和 ldexp()

#include <math.h>

double frexp(double x, int *exp);

#include <math.h>

double ldexp(double mantissa, int exp);

// frexp()伪代码：分解double类型浮点数x
double frexp(double x, int *exp) {
    // 步骤1：处理特殊值x=0
    if (x == 0.0) {
        *exp = 0;
        return 0.0;
    }
    
    // 步骤2：提取浮点数的符号位、原始指数、尾数位（基于IEEE 754）
    // IEEE 754 double格式：1位符号位(S) + 11位指数位(E) + 52位尾数位(M)
    unsigned long long bits = *(unsigned long long *)&x;  // 二进制位解析（仅示意）
    int sign_bit = (bits >> 63) & 0x1;  // 符号位：1为负，0为正
    int raw_exponent = ((bits >> 52) & 0x7FF) - 1023;  // 原始指数（减去偏置值1023）
    unsigned long long mantissa_bits = bits & 0x000FFFFFFFFFFFFF;  // 尾数位（52位）
    
    // 步骤3：构造初始尾码（含隐藏位1）
    double mantissa = 1.0 + (mantissa_bits / (double)(1LL << 52));  // 1.M形式
    
    // 步骤4：调整尾码至[0.5,1)区间，同步调整指数
    while (mantissa >= 1.0) {
        mantissa /= 2.0;
        raw_exponent += 1;
    }
    while (mantissa < 0.5) {
        mantissa *= 2.0;
        raw_exponent -= 1;
    }
    
    // 步骤5：应用符号位，设置指数输出，返回尾码
    *exp = raw_exponent;
    return (sign_bit ? -mantissa : mantissa);
}

// ldexp()伪代码：构造double类型浮点数
double ldexp(double mantissa, int exp) {
    // 步骤1：处理特殊尾码
    if (isnan(mantissa)) return NAN;
    if (isinf(mantissa)) return mantissa;
    if (mantissa == 0.0) return 0.0;
    
    // 步骤2：根据指数缩放尾码
    double result = mantissa;
    if (exp > 0) {
        for (int i = 0; i < exp; i++) {
            result *= 2.0;
            // 检查上溢
            if (isinf(result)) {
                errno = ERANGE;
                return (mantissa > 0) ? INFINITY : -INFINITY;
            }
        }
    } else if (exp < 0) {
        for (int i = 0; i < -exp; i++) {
            result /= 2.0;
            // 检查下溢
            if (result == 0.0) {
                errno = ERANGE;
                return 0.0;
            }
        }
    }
    // 注：实际实现中会用更高效的位操作替代循环，此处为示意
    
    return result;
}

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

// 数值标准化示例：计算a*b，先标准化再运算
double stable_multiply(double a, double b) {
    int exp_a, exp_b;
    // 分解a和b，得到归一化尾码
    double mant_a = frexp(a, &exp_a);
    double mant_b = frexp(b, &exp_b);
    
    // 尾码相乘（[0.5,1)×[0.5,1) = [0.25,1)）
    double mant_result = mant_a * mant_b;
    // 指数相加
    int exp_result = exp_a + exp_b;
    
    // 若尾码超出[0.5,1)，重新归一化
    if (mant_result < 0.5) {
        mant_result *= 2.0;
        exp_result -= 1;
    }
    
    // 重构结果
    return ldexp(mant_result, exp_result);
}

int main() {
    double a = 1.23e200;  // 大数值
    double b = 4.56e200;  // 大数值，直接相乘易上溢
    double result = stable_multiply(a, b);
    printf("稳定乘法结果：%e\n", result);
    return 0;
}

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

// 分析浮点数的精度构成
void analyze_float(double x) {
    int exp;
    double mant = frexp(x, &exp);
    printf("浮点数 %g 的分解结果：\n", x);
    printf("  归一化尾码：%g （范围：[0.5,1)）\n", mant);
    printf("  指数：%d\n", exp);
    printf("  验证：%g × 2^%d = %g\n", mant, exp, ldexp(mant, exp));
}

int main() {
    double x1 = 0.1;  // 典型的二进制无法精确表示的小数
    double x2 = 123.456;
    analyze_float(x1);
    printf("------------------------\n");
    analyze_float(x2);
    return 0;
}

// 错误用法：传入NULL指针
int *exp_ptr = NULL;
frexp(1.0, exp_ptr);  // 程序崩溃

// 正确用法：定义int变量，传入地址
int exp;
frexp(1.0, &exp);  // 正确

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

int main() {
    double result = ldexp(0.8, 1024);  // 上溢
    if (errno == ERANGE) {
        if (isinf(result)) {
            printf("错误：上溢，结果为无穷大\n");
        } else if (result == 0.0) {
            printf("错误：下溢，结果为0\n");
        }
    }
    return 0;
}

#include <math.h>
#include <stdio.h>
#include <errno.h>
#include <fenv.h>

// 浮点数调整函数：将x的尾码乘以scale_factor后重构
double adjust_float(double x, double scale_factor) {
    int exp;
    double mant;
    errno = 0;  // 重置错误码
    
    // 步骤1：分解原始浮点数
    printf("原始浮点数：%g\n", x);
    mant = frexp(x, &exp);
    if (errno != 0) {
        perror("frexp 错误");
        return NAN;
    }
    printf("分解结果：尾码=%.10f，指数=%d\n", mant, exp);
    
    // 步骤2：调整尾码（示例：乘以scale_factor）
    double new_mant = mant * scale_factor;
    printf("调整后尾码：%.10f（乘以%.2f）\n", new_mant, scale_factor);
    
    // 步骤3：重新归一化尾码（确保在[0.5,1)区间）
    while (new_mant >= 1.0) {
        new_mant /= 2.0;
        exp += 1;
    }
    while (new_mant < 0.5 && new_mant != 0.0) {
        new_mant *= 2.0;
        exp -= 1;
    }
    printf("归一化后：尾码=%.10f，指数=%d\n", new_mant, exp);
    
    // 步骤4：重构新浮点数，检测溢出/下溢
    feclearexcept(FE_ALL_EXCEPT);  // 清除之前的浮点异常
    double new_x = ldexp(new_mant, exp);
    if (fetestexcept(FE_OVERFLOW)) {
        fprintf(stderr, "错误：重构时发生上溢\n");
        return INFINITY;
    }
    if (fetestexcept(FE_UNDERFLOW)) {
        fprintf(stderr, "错误：重构时发生下溢\n");
        return 0.0;
    }
    
    // 步骤5：验证结果
    printf("重构后浮点数：%g\n", new_x);
    printf("验证：%.10f × 2^%d = %g\n", new_mant, exp, new_x);
    return new_x;
}

int main() {
    // 测试1：正常浮点数调整
    printf("==================== 测试1：正常调整 ====================\n");
    adjust_float(123.456, 1.5);  // 尾码乘以1.5
    
    // 测试2：可能上溢的调整
    printf("\n==================== 测试2：上溢测试 ====================\n");
    adjust_float(0.9, 1024);  // 尾码0.9×1024=921.6，指数叠加后易上溢
    
    return 0;
}

#include <math.h>
#include <stdio.h>
#include <errno.h>
#include <fenv.h>

int main() {
    errno = 0;  // 重置错误码
    feclearexcept(FE_ALL_EXCEPT);  // 清除浮点异常标志
    double res = ldexp(0.9, 1024);
    
    // 双重检测：errno + 浮点异常标志
    if ((errno == ERANGE) || fetestexcept(FE_OVERFLOW)) {
        if (isinf(res)) {
            fprintf(stderr, "异常：上溢，结果为无穷大\n");
            // 业务降级：用double最大值替代
            res = DBL_MAX;
        }
    }
    printf("处理后结果：%e\n", res);
    return 0;
}

#include <math.h>
#include <stdio.h>
#include <float.h>  // 包含DBL_EPSILON

// 验证逆运算一致性，允许浮点精度误差
int verify_inverse(double x) {
    int exp;
    double mant = frexp(x, &exp);
    double recon_x = ldexp(mant, exp);
    
    // 相对误差判断（适配不同数值范围）
    double rel_err = fabs(x - recon_x) / (fabs(x) + 1e-16);  // 避免除零
    if (rel_err <= DBL_EPSILON * 10) {  // 放宽10倍精度阈值
        printf("验证通过：x=%.12g，重构=%.12g\n", x, recon_x);
        return 1;
    } else {
        printf("偏差存在：x=%.12g，重构=%.12g，相对误差=%.1e\n", 
               x, recon_x, rel_err);
        return 0;
    }
}

int main() {
    // 测试典型场景：普通值、小数值、大数值、负值
    double test_cases[] = {123.456, 0.1, 1.23e200, -9.87e-50};
    for (size_t i=0; i<sizeof(test_cases)/sizeof(test_cases[0]); i++) {
        verify_inverse(test_cases[i]);
    }
    return 0;
}