#include #include #include #include #include #include #include #include #include #include #include #include namespace calx {

// 前方宣言 (operator+= / -= から使用)
static int mergeRequested(int req_a, int req_b);
static int mergeEffective(int eff_a, int eff_b);

// 5^n を繰り返し二乗法で計算 (O(M(n) log n))
// 10^n = 5^n * 2^n なので、2^n はシフトで処理し 5^n のみ計算
static Int pow5_fast(size_t n) {
    if (n == 0) return Int(1);
    if (n == 1) return Int(5);
    Int base(5);
    Int result(1);
    size_t exp = n;
    while (exp > 0) {
        if (exp & 1) result = result * base;
        exp >>= 1;
        if (exp > 0) base = base * base;
    }
    return result;
}

// 10^n を繰り返し二乗法で計算 (O(M(n) log n))
static Int pow10_fast(size_t n) {
    if (n == 0) return Int(1);
    if (n == 1) return Int(10);
    Int base(10);
    Int result(1);
    size_t exp = n;
    while (exp > 0) {
        if (exp & 1) result = result * base;
        exp >>= 1;
        if (exp > 0) base = base * base;
    }
    return result;
}



// defaultPrecision() と rounding_mode_ は Float.hpp で inline static thread_local として定義済み。
// DLL 境界を越えても呼び出し側の TU に変数が存在するため、エクスポート不要。
thread_local int64_t Float::emin_ = Float::EXPONENT_MIN;
thread_local int64_t Float::emax_ = Float::EXPONENT_MAX;
thread_local unsigned Float::exception_flags_ = 0;

void Float::checkExponentBounds() {
    if (is_infinity_ || is_nan_ || mantissa_.isZero()) {
        return;
    }
    if (exponent_ > EXPONENT_MAX) {
        // 指数オーバーフロー → ±∞
        is_infinity_ = true;
        effective_bits_ = 0;
        requested_bits_ = 0;
        mantissa_ = Int(0);
        exponent_ = 0;
    } else if (exponent_ < EXPONENT_MIN) {
        // 指数アンダーフロー → 0
        mantissa_ = Int(0);
        exponent_ = 0;
        is_negative_ = false;
        effective_bits_ = 0;
        requested_bits_ = 0;
    }
}

// 10進数桁数からビット数への変換（log₂(10) ≈ 3.32）
int Float::precisionToBits(int precision) {
    // 10 進 N 桁を正確に保証するには、N * log2(10) ビットに加えて
    // ガードビットが必要。ガードビットなしでは最終 1-2 桁が丸め誤差で不正確になる。
    // 8 ビットのガード ≈ 2.4 桁分で末尾桁を保護する。
    constexpr int GUARD = 8;
    return static_cast (std::ceil(precision * 3.32192809488736)) + GUARD;
}

// ビット数から10進数桁数への変換
int Float::bitsToPrecision(int bits) {
    if (bits <= 0) return 1;

    // precisionToBits で追加したガードビットを差し引いてから桁数に変換
    // precisionToBits(N) = ceil(N * log2(10)) + GUARD なので、
    // 逆変換では GUARD を引く
    constexpr int GUARD = 8;  // precisionToBits と同じ値
    int effective_bits = std::max(1, bits - GUARD);
    int precision = static_cast (std::floor(effective_bits / 3.32192809488736));

    return std::max(1, precision);
}

//======================================================================
// コンストラクタ
//======================================================================

Float::Float()
    : mantissa_(0), exponent_(0), is_negative_(false),
      is_infinity_(false), is_nan_(false),
      effective_bits_(INT_MAX), requested_bits_(INT_MAX) {
}

Float::Float(int value)
    : mantissa_(std::abs(value)), exponent_(0), is_negative_(value < 0),
      is_infinity_(false), is_nan_(false),
      effective_bits_(INT_MAX), requested_bits_(INT_MAX) {
    normalize();
}

Float::Float(int64_t value)
    : mantissa_(std::abs(value)), exponent_(0), is_negative_(value < 0),
      is_infinity_(false), is_nan_(false),
      effective_bits_(INT_MAX), requested_bits_(INT_MAX) {
    normalize();
}

Float::Float(int64_t mantissa, int64_t exponent, bool is_negative)
    : mantissa_(std::abs(mantissa)), exponent_(exponent), is_negative_(mantissa < 0 ? !is_negative : is_negative),
    is_infinity_(false), is_nan_(false),
    effective_bits_(INT_MAX), requested_bits_(INT_MAX) {
    // マイナスの値が渡された場合は符号を反転
    if (mantissa < 0) {
        mantissa_ = Int(-mantissa);
    }
    normalize();
}

Float::Float(const Int& value)
    : mantissa_(abs(value)), exponent_(0), is_negative_(value.isNegative()),
      is_infinity_(false), is_nan_(false),
      effective_bits_(INT_MAX), requested_bits_(INT_MAX) {
    normalize();
}

Float::Float(double value) : is_infinity_(false), is_nan_(false),
    effective_bits_(53), requested_bits_(precisionToBits(defaultPrecision())) {
    // 特殊値の処理
    if (std::isnan(value)) {
        is_nan_ = true;
        is_negative_ = false;
        mantissa_ = Int(0);
        exponent_ = 0;
        effective_bits_ = 0;
        requested_bits_ = 0;
        return;
    }

    is_negative_ = std::signbit(value);
    value = std::abs(value);

    if (std::isinf(value)) {
        is_infinity_ = true;
        mantissa_ = Int(0);
        exponent_ = 0;
        effective_bits_ = 0;
        requested_bits_ = 0;
        return;
    }

    // ゼロの処理
    if (value == 0.0) {
        mantissa_ = Int(0);
        exponent_ = 0;
        effective_bits_ = INT_MAX;
        requested_bits_ = INT_MAX;
        return;
    }

    // doubleを直接扱う（frexp使用せず）
    // 浮動小数点数のビット表現を取得
    uint64_t bits;
    std::memcpy(&bits, &value, sizeof(double));

    // IEEE 754 倍精度形式からの抽出
    // 符号ビット (1bit)、指数部 (11bits)、仮数部 (52bits)
    uint64_t exponent_bits = (bits >> 52) & 0x7FF;
    uint64_t mantissa_bits = bits & 0x000FFFFFFFFFFFFF;

    // バイアス付き指数（IEEE 754では1023）
    int64_t true_exponent = static_cast (exponent_bits) - 1023;

    // 仮数部には暗黙の先頭ビット（1）を追加
    mantissa_ = Int(mantissa_bits | 0x10000000000000); // 2^52を加える

    // 指数部の調整（仮数部が2^52で乗算されているため）
    exponent_ = true_exponent - 52;

    // 精度フィールドの判定: バイナリ指数分析
    // value = full_mantissa × 2^(true_exponent - 52)
    // 仮数部の末尾ゼロを除去して奇数部分 × 2^e_adj の形にする
    // e_adj >= 0 なら整数 → exact (INT_MAX)
    // e_adj < 0 で |e_adj| <= 20 なら綺麗な10進小数 → exact (INT_MAX)
    if (value == 0.0) {
        effective_bits_ = INT_MAX;
        requested_bits_ = INT_MAX;
    } else if (exponent_bits != 0x7FF) {  // inf, NaN 以外
        uint64_t m = mantissa_bits | 0x10000000000000;
        int trailing_zeros = 0;
        while ((m & 1) == 0) {
            m >>= 1;
            trailing_zeros++;
        }
        int64_t e_adj = true_exponent - 52 + trailing_zeros;
        if ((e_adj >= 0) || ((-e_adj) <= 20)) {
            effective_bits_ = INT_MAX;
            requested_bits_ = INT_MAX;
        }
        // それ以外: effective_bits_ = 53, requested_bits_ = default (初期化子リストで設定済み)
    }

    normalize();
}

Float::Float(std::string_view str)
    : is_infinity_(false), is_nan_(false),
      effective_bits_(0), requested_bits_(0) {
    // 特殊値のチェック
    std::string s(str);
    std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::tolower(c); });

    if (s == "nan" || s == "inf" || s == "+inf" || s == "-inf" || s == "infinity" || s == "+infinity" || s == "-infinity") {
        if (s == "nan") {
            is_nan_ = true;
            is_negative_ = false;
        } else {
            is_infinity_ = true;
            is_negative_ = (s[0] == '-');
        }
        mantissa_ = 0;
        exponent_ = 0;
        return;
    }

    // 高精度な10進文字列解析
    // 符号の処理
    size_t pos = 0;
    is_negative_ = false;
    if (pos < str.size() && (str[pos] == '+' || str[pos] == '-')) {
        is_negative_ = (str[pos] == '-');
        pos++;
    }

    // 整数部と小数部の桁を集める
    std::string digits;
    int decimal_digits = 0;
    bool found_dot = false;
    int exponent_10 = 0;

    for (; pos < str.size(); pos++) {
        if (str[pos] == '.') {
            found_dot = true;
        } else if (str[pos] == 'e' || str[pos] == 'E') {
            // 指数部
            pos++;
            exponent_10 = std::stoi(std::string(str.substr(pos)));
            break;
        } else if (str[pos] >= '0' && str[pos] <= '9') {
            digits += str[pos];
            if (found_dot) decimal_digits++;
        } else {
            break;
        }
    }

    if (digits.empty()) {
        // 解析失敗
        is_nan_ = true;
        mantissa_ = 0;
        exponent_ = 0;
        is_negative_ = false;
        return;
    }

    // 先頭のゼロを除去
    size_t first_nonzero = digits.find_first_not_of('0');
    if (first_nonzero == std::string::npos) {
        // 全て0
        mantissa_ = Int(0);
        exponent_ = 0;
        is_negative_ = false;
        effective_bits_ = INT_MAX;
        requested_bits_ = INT_MAX;
        return;
    }

    // 有効桁数から精度ビット数を計算
    int significant_digits = static_cast (digits.size() - first_nonzero);
    int string_precision_bits = precisionToBits(significant_digits);

    // 10進数字列をIntに変換
    Int numerator(digits);

    // value = numerator * 10^(exponent_10 - decimal_digits)
    int net_exp10 = exponent_10 - decimal_digits;

    if (net_exp10 == 0) {
        // value = numerator（整数）
        mantissa_ = numerator;
        exponent_ = 0;
        effective_bits_ = string_precision_bits;
        requested_bits_ = string_precision_bits;
        normalize();
    } else if (net_exp10 > 0) {
        // value = numerator * 10^net_exp10 = numerator * 5^e * 2^e
        Int five_pow = pow5_fast(static_cast (net_exp10));
        mantissa_ = numerator * five_pow;
        exponent_ = net_exp10; // 2^net_exp10
        effective_bits_ = string_precision_bits;
        requested_bits_ = string_precision_bits;
        normalize();
    } else {
        // value = numerator / 10^D = numerator / (5^D * 2^D)
        // 5^D で除算し、2^D は exponent 調整で処理
        size_t D = static_cast (-net_exp10);
        Int five_pow = pow5_fast(D);

        int num_bits = static_cast (numerator.bitLength());
        int den_bits = static_cast (five_pow.bitLength());
        // quotient が string_precision_bits + guard ビット確保されるよう設定
        // quotient_bits ≈ num_bits + target_bits - den_bits ≥ string_precision_bits + 20
        int target_bits = std::max(den_bits - num_bits, 0) + string_precision_bits + 20;

        Int scaled = numerator << target_bits;
        Int remainder;
        Int quotient = IntOps::divmod(scaled, five_pow, remainder);

        mantissa_ = std::move(quotient);
        exponent_ = -static_cast (target_bits) - static_cast (D);
        effective_bits_ = string_precision_bits;
        requested_bits_ = string_precision_bits;
        normalize();
    }
}

Float::Float(const Int& mantissa, int64_t exponent, bool is_negative)
    : mantissa_(mantissa), exponent_(exponent), is_negative_(is_negative),
      is_infinity_(false), is_nan_(false),
      effective_bits_(INT_MAX), requested_bits_(INT_MAX) {
    normalize();
}

Float::Float(Int&& mantissa, int64_t exponent, bool is_negative)
    : mantissa_(std::move(mantissa)), exponent_(exponent), is_negative_(is_negative),
      is_infinity_(false), is_nan_(false),
      effective_bits_(INT_MAX), requested_bits_(INT_MAX) {
    normalize();
}

//======================================================================
// 代入演算子
//======================================================================

Float& Float::operator=(int64_t value) {
    mantissa_ = Int(std::abs(value));
    exponent_ = 0;
    is_negative_ = (value < 0);
    is_infinity_ = false;
    is_nan_ = false;
    effective_bits_ = INT_MAX;
    requested_bits_ = INT_MAX;
    normalize();
    return *this;
}

Float& Float::operator=(double value) {
    *this = Float(value);
    return *this;
}

//======================================================================
// 演算子実装
//======================================================================

Float& Float::operator+=(const Float& rhs) {
    // 特殊値は従来パスに委譲
    if (isNaN() || rhs.isNaN()) [[unlikely]] { *this = Float::nan(); return *this; }
    if (isInfinity() || rhs.isInfinity()) [[unlikely]] {
        *this = static_cast (*this) + rhs; return *this;
    }
    if (isZero()) [[unlikely]] { *this = rhs; return *this; }
    if (rhs.isZero()) [[unlikely]] return *this;

    // 精度フィールドを先に読む (this が上書きされる前に)
    int eff = mergeEffective(effective_bits_, rhs.effective_bits_);
    int req = mergeRequested(requested_bits_, rhs.requested_bits_);

    if (is_negative_ == rhs.is_negative_) {
        // 同符号: 仮数加算 (桁落ちなし)
        addUnsignedInPlace(rhs);
        effective_bits_ = eff;
        requested_bits_ = req;
    } else {
        // 異符号: 桁落ち計算が複雑なため従来パス
        int64_t mag_this = static_cast (mantissa_.bitLength()) + exponent_;
        int64_t mag_rhs = static_cast (rhs.mantissa_.bitLength()) + rhs.exponent_;
        int64_t max_mag = std::max(mag_this, mag_rhs);
        bool this_neg = is_negative_;

        subtractUnsignedInPlace(rhs);

        if (isZero()) {
            if (eff >= INT_MAX) {
                effective_bits_ = INT_MAX;
                requested_bits_ = INT_MAX;
            } else {
                effective_bits_ = 0;
                requested_bits_ = req;
            }
        } else {
            is_negative_ = is_negative_ ? rhs.isNegative() : this_neg;
            int64_t result_mag = static_cast (mantissa_.bitLength()) + exponent_;
            int lost_bits = static_cast (std::max(int64_t(0), max_mag - result_mag));
            if (eff >= INT_MAX) {
                effective_bits_ = INT_MAX;
            } else {
                effective_bits_ = std::max(1, eff - lost_bits);
            }
            requested_bits_ = req;
        }
    }
    return *this;
}

Float& Float::operator-=(const Float& rhs) {
    // 特殊値は従来パスに委譲
    if (isNaN() || rhs.isNaN()) [[unlikely]] { *this = Float::nan(); return *this; }
    if (isInfinity() || rhs.isInfinity()) [[unlikely]] {
        *this = static_cast (*this) - rhs; return *this;
    }
    if (isZero()) [[unlikely]] {
        *this = rhs;
        is_negative_ = !is_negative_;
        return *this;
    }
    if (rhs.isZero()) [[unlikely]] return *this;

    int eff = mergeEffective(effective_bits_, rhs.effective_bits_);
    int req = mergeRequested(requested_bits_, rhs.requested_bits_);

    if (is_negative_ != rhs.is_negative_) {
        // 異符号: (+a)-(-b)=a+b → 仮数加算 (桁落ちなし)
        addUnsignedInPlace(rhs);
        effective_bits_ = eff;
        requested_bits_ = req;
    } else {
        // 同符号: 仮数減算 (桁落ちあり)
        int64_t mag_this = static_cast (mantissa_.bitLength()) + exponent_;
        int64_t mag_rhs = static_cast (rhs.mantissa_.bitLength()) + rhs.exponent_;
        int64_t max_mag = std::max(mag_this, mag_rhs);
        bool this_neg = is_negative_;

        subtractUnsignedInPlace(rhs);

        if (isZero()) {
            if (eff >= INT_MAX) {
                effective_bits_ = INT_MAX;
                requested_bits_ = INT_MAX;
            } else {
                effective_bits_ = 0;
                requested_bits_ = req;
            }
        } else {
            // subtractUnsigned: is_negative_=true は |this| < |rhs|
            // operator-: 同符号で |this|>=|rhs| → sign=this_neg, |this|<|rhs| → sign=!this_neg
            is_negative_ = is_negative_ ? !this_neg : this_neg;
            int64_t result_mag = static_cast (mantissa_.bitLength()) + exponent_;
            int lost_bits = static_cast (std::max(int64_t(0), max_mag - result_mag));
            if (eff >= INT_MAX) {
                effective_bits_ = INT_MAX;
            } else {
                effective_bits_ = std::max(1, eff - lost_bits);
            }
            requested_bits_ = req;
        }
    }
    return *this;
}

Float& Float::operator*=(const Float& rhs) {
    *this = std::move(*this) * rhs;
    return *this;
}

Float& Float::operator/=(const Float& rhs) {
    *this = std::move(*this) / rhs;
    return *this;
}

//======================================================================
// メソッド実装
//======================================================================

bool Float::isZero() const {
    return !is_infinity_ && !is_nan_ && mantissa_.isZero();
}

int Float::precision() const {
    if (isZero() || isInfinity() || isNaN()) {
        return defaultPrecision();
    }
    int eff = std::min(effective_bits_, requested_bits_);
    if (eff >= INT_MAX) {
        // exact な値 (整数由来) → defaultPrecision 互換
        return defaultPrecision();
    }
    return Float::bitsToPrecision(eff);
}

Float& Float::setPrecision(int precision) {
    if (isZero() || isInfinity() || isNaN()) {
        return *this;
    }

    int precision_bits = precisionToBits(precision);
    int current_bits = static_cast (mantissa_.bitLength());

    // requested_bits_ を更新
    requested_bits_ = precision_bits;

    if (current_bits < precision_bits) {
        // 精度不足の場合、仮数部を左シフトしてパディング
        // 値は変わらない: (mantissa << shift) * 2^(exponent - shift) = mantissa * 2^exponent
        // effective_bits_ は変えない (パディングしても信頼性は増えない)
        int shift = precision_bits - current_bits;
        mantissa_ <<= shift;
        exponent_ -= shift;
        checkExponentBounds();
    }

    round(precision_bits, roundingMode());
    return *this;
}

Float& Float::setResultPrecision(int precision) {
    setPrecision(precision);
    if (!isZero() && !isInfinity() && !isNaN()) {
        effective_bits_ = precisionToBits(precision);
    }
    return *this;
}

void Float::truncateToApprox(int precision) {
    if (isZero() || isInfinity() || isNaN()) [[unlikely]] return;

    int target_bits = precisionToBits(precision);
    requested_bits_ = target_bits;
    int bl = static_cast (mantissa_.bitLength());

    if (bl < target_bits) {
        // パディング: setPrecision と同様に仮数部を拡張
        int shift = target_bits - bl;
        mantissa_ <<= shift;
        exponent_ -= shift;
        checkExponentBounds();
        return;
    }

    if (bl <= target_bits) return;

    // ワード単位で下位を切り捨て (ビットシフト・丸め処理なし)
    // floor 除算: 最大63ビットの余剰を保持 → ガードビットで吸収
    int words_to_drop = (bl - target_bits) / 64;
    if (words_to_drop <= 0) return;

    int shift = words_to_drop * 64;
    mantissa_ >>= shift;  // bit_shift==0 → erase のみ (O(1) memmove)
    exponent_ += shift;
}

void Float::normalize() {
    if (is_infinity_ || is_nan_ || mantissa_.isZero()) [[unlikely]] {
        return;
    }

    // in-place で両端のゼロワードを除去 (alloc なし)
    size_t lsb_removed = mantissa_.trimZeroWords();
    if (lsb_removed > 0) {
        exponent_ += static_cast (64 * lsb_removed);
    }

    if (mantissa_.isZero()) [[unlikely]] {
        exponent_ = 0;
        is_negative_ = false;
    }

    checkExponentBounds();
}

void Float::round(int precision_bits, RoundingMode mode) {
    if (isZero() || isInfinity() || isNaN()) {
        return;
    }

    int bit_length = static_cast (mantissa_.bitLength());
    if (bit_length <= precision_bits) {
        return;  // 既に必要精度以下
    }

    int shift = bit_length - precision_bits;

    // ── ガードビット・スティッキービットを生リムから直接抽出 ──
    // Int コピーやマスク生成を回避し、O(n) の読み取りのみで丸め判定を行う。
    const uint64_t* data = mantissa_.data();
    size_t n = mantissa_.size();

    // guard bit = bit (shift - 1): 精度境界の直下のビット
    bool guard_bit = false;
    if (shift >= 1) {
        size_t gw = static_cast (shift - 1) / 64;
        unsigned gb = static_cast ((shift - 1) % 64);
        if (gw < n) {
            guard_bit = ((data[gw] >> gb) & 1) != 0;
        }
    }

    // sticky bits = bits 0..(shift-2): いずれかが非ゼロなら true
    bool sticky = false;
    if (shift >= 2) {
        size_t full_words = static_cast (shift - 1) / 64;
        for (size_t i = 0; i < full_words && i < n; ++i) {
            if (data[i] != 0) { sticky = true; break; }
        }
        if (!sticky && full_words < n) {
            unsigned partial = static_cast ((shift - 1) % 64);
            if (partial > 0) {
                uint64_t mask = (1ULL << partial) - 1;
                if (data[full_words] & mask) sticky = true;
            }
        }
    }

    // 下位ビットを削除
    mantissa_ >>= shift;
    exponent_ += shift;

    // 丸め方向を判定
    bool any_discarded = guard_bit || sticky;
    bool round_up = false;

    switch (mode) {
        case RoundingMode::ToNearest:
            // 偶数丸め: guard=1 かつ (sticky=1 または結果 LSB=1) で切り上げ
            if (guard_bit) {
                round_up = sticky || ((mantissa_.word(0) & 1) != 0);
            }
            break;

        case RoundingMode::TowardZero:
            break;

        case RoundingMode::TowardPositive:
            round_up = !is_negative_ && any_discarded;
            break;

        case RoundingMode::TowardNegative:
            round_up = is_negative_ && any_discarded;
            break;

        case RoundingMode::AwayFromZero:
            round_up = any_discarded;
            break;
    }

    if (round_up) {
        IntOps::addDelta(mantissa_, 1);
        if (static_cast (mantissa_.bitLength()) > precision_bits) {
            mantissa_ >>= 1;
            exponent_ += 1;
        }
    }

    // 丸めで切り捨てたので effective_bits_ は precision_bits 以下に制限
    if (effective_bits_ > precision_bits && effective_bits_ < INT_MAX) {
        effective_bits_ = precision_bits;
    }

    // MIN 方式: 丸めにより effective_bits_ を precision_bits 以下にクランプ
    if constexpr (PRECISION_POLICY == PrecisionPolicy::MIN_PROPAGATION) {
        if (effective_bits_ < INT_MAX) {
            effective_bits_ = std::min(effective_bits_, precision_bits);
        }
    }

    // 指数部の範囲チェック
    checkExponentBounds();
}

void Float::subnormalize(RoundingMode mode) {
    // 特殊値・ゼロは何もしない
    if (isZero() || isInfinity() || isNaN()) return;

    // 正規数範囲内なら何もしない
    // IEEE 754: 正規数の最小指数は emin, 仮数ビット数 p のとき
    // サブノーマル条件: exponent < emin + p - 1 (= 仮数先頭ビットが emin に達しない)
    int bit_length = static_cast (mantissa_.bitLength());
    // 実効指数 = exponent_ + bit_length - 1 (MSB の位置)
    int64_t msb_exp = exponent_ + static_cast (bit_length) - 1;

    if (msb_exp >= emin_) return;  // 正規数

    // シフト量: 仮数を右にずらして emin に合わせる
    int64_t shift = emin_ - msb_exp;

    if (shift >= bit_length) {
        // 完全アンダーフロー → ゼロ
        mantissa_ = Int(0);
        exponent_ = 0;
        is_negative_ = false;
        effective_bits_ = 0;
        requested_bits_ = 0;
        raiseException(FE_UNDERFLOW | FE_INEXACT);
        return;
    }

    // 丸めのためのガードビット/スティッキービット抽出
    int shift_int = static_cast (shift);
    bool guard_bit = mantissa_.getBit(shift_int - 1);
    bool sticky = false;
    for (int i = 0; i < shift_int - 1; ++i) {
        if (mantissa_.getBit(i)) { sticky = true; break; }
    }
    bool any_discarded = guard_bit || sticky;

    // シフト実行
    mantissa_ >>= shift_int;
    exponent_ += shift_int;  // = emin - (bit_length - 1) + shift = emin

    // 丸め判定
    bool round_up = false;
    switch (mode) {
        case RoundingMode::ToNearest:
            if (guard_bit) {
                round_up = sticky || ((mantissa_.word(0) & 1) != 0);
            }
            break;
        case RoundingMode::TowardZero:
            break;
        case RoundingMode::TowardPositive:
            round_up = !is_negative_ && any_discarded;
            break;
        case RoundingMode::TowardNegative:
            round_up = is_negative_ && any_discarded;
            break;
        case RoundingMode::AwayFromZero:
            round_up = any_discarded;
            break;
    }

    if (round_up) {
        IntOps::addDelta(mantissa_, 1);
    }

    if (mantissa_.isZero()) {
        exponent_ = 0;
        is_negative_ = false;
        effective_bits_ = 0;
        requested_bits_ = 0;
    }

    if (any_discarded) {
        raiseException(FE_UNDERFLOW | FE_INEXACT);
    }
}

std::string Float::toString(int precision) const {
    if (isNaN()) {
        return "NaN";
    }
    
    if (isInfinity()) {
        return is_negative_ ? "-Infinity" : "Infinity";
    }
    
    if (isZero()) {
        return "0.0";
    }

    // デフォルトでは現在の精度を使用
    if (precision < 0) {
        precision = this->precision();
    }

    // 指数部のサイズで表示形式を決定
    if (exponent_ >= 0 && exponent_ < precision) {
        return toDecimalString(precision);
    } else {
        return toScientificString(precision);
    }
}

std::string Float::toDecimalString(int precision) const {
    if (isNaN()) return "NaN";
    if (isInfinity()) return is_negative_ ? "-Infinity" : "Infinity";
    if (isZero()) return "0.0";

    if (precision < 0) {
        precision = std::max(1, this->precision());
    }

    // value = mantissa * 2^exponent  (mantissa >= 0)
    // |value| * 10^D = mantissa * 10^D * 2^exponent
    //                = mantissa * (2^D * 5^D) * 2^exponent
    //                = mantissa * 5^D * 2^(D + exponent)
    //
    // shift = D + exponent
    //   shift >= 0: N = (mantissa * 5^D) << shift    (exact)
    //   shift <  0: N = (mantissa * 5^D) >> (-shift)  (truncation)
    //
    // N = floor(|value| * 10^D) を10進文字列化し、小数点を挿入する。

    int D = precision;

    // ガードビット: 2進→10進変換の丸め (右シフトの切り捨て) で末尾桁が
    // 不正確になることを防ぐため、仮数部に追加ビットを付与して計算する。
    constexpr int GUARD_BITS = 20;  // 20 ビット ≈ 6 桁分のガード
    Int extended_mantissa = mantissa_ << GUARD_BITS;
    int64_t adjusted_exponent = exponent_ - GUARD_BITS;

    Int pow5 = pow(Int(5), static_cast (D));
    Int product = extended_mantissa * pow5;

    int64_t shift = static_cast (D) + adjusted_exponent;

    Int N;
    if (shift >= 0) {
        N = product << static_cast (shift);
    } else {
        int rshift = static_cast (-shift);
        N = product >> rshift;
        // 四捨五入: 切り捨てられるビット列の MSB が 1 なら繰り上げ
        if (rshift >= 1 && product.getBit(rshift - 1)) {
            N += 1;
        }
    }

    // N = round(|value| * 10^D)
    std::string digits = N.toString();

    // 整数部の桁数を |value| の大きさから独立に計算
    // (N の桁数は 2 進丸めの影響で期待より多くなることがある)
    int intDigits;
    {
        double val = std::abs(toDouble());
        if (val >= 1.0)
            intDigits = static_cast (std::floor(std::log10(val))) + 1;
        else
            intDigits = 0;
    }
    int expectedLen = intDigits + D;
    if (static_cast (digits.size()) > expectedLen && expectedLen > 0) {
        digits.resize(expectedLen);
    }

    std::string result;
    if (is_negative_) result += "-";

    if (static_cast