原理

double 由以下部分组成：

1. 符号位
2. 指数部分
3. 尾数部分

• 符号位的含义：为 0 表示正数，为 1 表示负数。
• 指数部分的含义：在规格化数中，指数部分的整型值减去 1023 就是实际的指数值。在非规格化数中，指数恒为 -1022 这个常数。
• 尾数部分：尾数部分的整型值就是它的值，不像指数部分那样需要分别处理。

规格化数的值：
$$\text{value}=(-1{)}^{\text{sign}}\times 2^{\text{exponent}-1023}\times \left(1+\frac{\text{mantissa}}{2^{52}}\right)$$

非规格化数的值：
$$\text{value}=(-1{)}^{\text{sign}}\times 2^{-1022}\times \left(\frac{\text{mantissa}}{2^{52}}\right)$$

浮点特殊值

NaN

• 指数部分所有位都为 1.
• 尾数部分不为 0.

正无穷、负无穷

• 指数部分所有位都为 1.
• 尾数部分所有位都为 0.

则根据符号位来确定是正无穷还是负无穷。符号位为 0 则是正无穷，符号位为 1 则是负无穷。

DoubleBitView

设计一个类，用来解析 double 的位结构

#pragma once
#include "base/bit/bit.h"
#include "base/math/FloatNumberValueType.h"
#include <cstdint>namespace base
{namespace bit{class DoubleBitView{private:union Union{double _double;uint64_t _uint64;};Union _value_union{};public:constexpr DoubleBitView() = default;constexpr DoubleBitView(double value){_value_union._double = value;}constexpr double Value() const{return _value_union._double;}constexpr uint64_t AsUint64() const{return _value_union._uint64;}////// @brief 尾数部分的位。////// @return///constexpr uint64_t MantissaBits() const{return base::bit::ReadBits(_value_union._uint64, 0, 52);}////// @brief 指数部分的位。////// @return///constexpr uint64_t ExponentBits() const{return base::bit::ReadBits(_value_union._uint64, 52, 63);}////// @brief 符号位。////// @return///constexpr bool SignBit() const{return base::bit::ReadBit(_value_union._uint64, 63);}////// @brief 浮点值的类型。////// @return///constexpr base::bit::FloatNumberValueType ValueType() const{if (ExponentBits() == base::bit::ReadBits(UINT64_MAX, 52, 63)){// 指数位全为 1if (MantissaBits() != 0){// 尾数位不全为 0,return base::bit::FloatNumberValueType::NaN;}// 尾数位全为 0if (!SignBit()){// 正无穷return base::bit::FloatNumberValueType::PositiveInfinite;}// 负无穷return base::bit::FloatNumberValueType::NegativeInfinite;}// 指数位不全为 1if (ExponentBits() == 0){// 指数位全为 0return base::bit::FloatNumberValueType::Denormalized;}return base::bit::FloatNumberValueType::Normalized;}////// @brief 是正数。////// @return///constexpr bool Positive() const{// 符号位位 0 则是正数return !SignBit();}////// @brief 是负数。////// @return///constexpr bool Negative() const{// 符号位位 1 则是负数return SignBit();}};} // namespace bit
} // namespace base

分数类

有了 double 的位结构之后，分数类就可以基于它进行构造了

base::Fraction::Fraction(base::Double const &value)
{if (value.Value() == 0.0){SetNum(0);SetDen(1);return;}base::bit::DoubleBitView view{value.Value()};switch (view.ValueType()){case base::bit::FloatNumberValueType::Normalized:{base::Fraction f1 = base::pow(base::BigInteger{2},base::BigInteger{view.ExponentBits() - 1023});base::Fraction f2 = base::Fraction{view.MantissaBits(),base::pow(base::BigInteger{2}, base::BigInteger{52}),};base::Fraction value = f1 * (1 + f2);if (view.Positive()){*this = value;}else{*this = -value;}break;}case base::bit::FloatNumberValueType::Denormalized:{base::Fraction f1 = base::pow(base::BigInteger{2},base::BigInteger{-1022});base::Fraction f2 = base::Fraction{view.MantissaBits(),base::pow(base::BigInteger{2}, base::BigInteger{52}),};base::Fraction value = f1 * f2;if (view.Positive()){*this = value;}else{*this = -value;}break;}case base::bit::FloatNumberValueType::NaN:{throw std::invalid_argument{CODE_POS_STR + "此浮点数是 NaN."};}case base::bit::FloatNumberValueType::PositiveInfinite:{throw std::invalid_argument{CODE_POS_STR + "此浮点数是正无穷。"};}case base::bit::FloatNumberValueType::NegativeInfinite:{throw std::invalid_argument{CODE_POS_STR + "此浮点数是负无穷。"};}default:{throw std::runtime_error{CODE_POS_STR + "非法的枚举值。"};}}
}

无损地将标准库中的 $\pi$ 常数转换为分数

#include "base/math/Fraction.h"
#include "base/wrapper/number-wrapper.h"
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <numbers>
#include <stdlib.h>int main()
{{base::Fraction f{base::Double{std::numbers::pi}};constexpr int precision = 512;std::cout << "分数: " << f << std::endl;std::cout << "std::numbers::pi: \t\t"<< std::setprecision(precision)<< std::numbers::pi<< std::endl;std::cout << "分数表示的 pi 转为 double: \t"<< std::setprecision(precision)<< static_cast<double>(f)<< std::endl;std::cout << "误差: "<< std::setprecision(precision)<< static_cast<double>(f) - std::numbers::pi<< std::endl;}
}

运行结果

分数: 884279719003555 / 281474976710656
std::numbers::pi:               3.141592653589793115997963468544185161590576171875
分数表示的 pi 转为 double:      3.141592653589793115997963468544185161590576171875
误差: 0

$\pi$ 用分数近似表示就是 884279719003555 / 281474976710656