C++转Rust时StandardForm指数调整问题，测试用例失败求助

我正在将旧的C++代码转换为Rust，实现StandardForm类（用于表示标准形式数字，包含尾数mantissa与指数exponent）时遇到错误，相关代码与问题如下：

C++原代码 #

class StandardForm /* : public deathsdoor::nodes::TreeNode<deathsdoor::math::NodeType>*/ {
        private:
            double num = 1;
            int power = 1;
            bool isInValidRange() const noexcept{
                return (num >= 1 && num <= 10) || (num >= -10 && num <= -1);
            }
            //...
          public :
              StandardForm(const double& n,const int& pow) noexcept: TreeNode(NodeType::StandardFormNumber){
                // this had to be done for some reason
                if(isInValidRange()){
                    setPower(pow);
                    setNum(n);
                }
                else{
                    setNum(n);
                    setPower(pow);
                }
            }  

            void setNum(const double& num) noexcept{
                this->num = num;

                if (isInValidRange()) return;

                double absNumber = std::abs(num);
                int logZehn = std::ceil(std::log10(absNumber));
                this->num /= std::pow(10, logZehn);
                this->power = logZehn;

                if (this->num < 0) this->num = -this->num;

                if(this->num > 0 && this->num < 1) {
                    this->num *= 10;
                    this->power -= 1;
                }
            }

            void setPower(const int& power) noexcept{
                this->power = power;
            }
};
            //...

我的Rust实现尝试 #

/// Represents a number in standard form.
///
/// The `Standardform` struct holds the significand (mantissa) of the number
/// and an exponent that determines the power of 10 by which the significand should be multiplied.
#[derive(Debug, PartialEq)]
pub struct StandardForm {
    mantissa: f64,
    exponent: i8,
}

impl StandardForm {
    /// Creates a new instance of StandardForm with the given mantissa and exponent
    pub fn new(mantissa: f64, exponent: i8) -> Self {
        let mut instance = Self { mantissa, exponent };
        instance.adjust();
        instance
    }

    fn in_range(&self) -> bool {
        (self.mantissa >= 1.0 && self.mantissa <= 10.0)
            || (self.mantissa >= -10.0 && self.mantissa <= -1.0)
    }

    fn adjust(&mut self) {
        if self.in_range() {
            return;
        }

        let abs_number = f64::abs(self.mantissa);
        let log_zehn = f64::ceil(f64::log10(abs_number));
        self.mantissa /= f64::powf(10.0, log_zehn);
        self.exponent = log_zehn as i8;

        if self.mantissa < 0.0 {
            self.mantissa = -self.mantissa;
        }

        if self.mantissa > 0.0 && self.mantissa < 1.0 {
            self.mantissa *= 10.0;
            self.exponent -= 1;
        }
    }
}

失败的测试用例 #

以下测试用例在C++中可通过，但Rust实现全部失败：

#[test]
fn test_normalize_with_invalid_range() {
    let mut sf = StandardForm::new(20.0, 3);
    sf.adjust();
    assert_eq!(sf.mantissa, 2.0);
    assert_eq!(sf.exponent, 4);
}

#[test]
fn test_normalize_with_small_mantissa() {
    let mut sf = StandardForm::new(-0.25, 2);
    sf.adjust();
    assert_eq!(sf.mantissa, -2.5);
    assert_eq!(sf.exponent, 1);
}

#[test]
fn test_normalize_with_large_negative_mantissa() {
    let mut sf = StandardForm::new(-750.0, 4);
    sf.adjust();
    assert_eq!(sf.mantissa, -7.5);
    assert_eq!(sf.exponent, 6);
}

问题排查与修复 #

核心问题分析 #

1. 逻辑偏离需求：原Rust代码仅单独标准化mantissa，完全忽略了mantissa * 10^exponent的整体数值，导致指数计算错误。
2. 符号处理错误：代码强制将负尾数转为正，不符合测试用例对符号保留的要求。
3. 未匹配C++初始化顺序：C++构造函数先使用默认值判断范围，再按顺序设置指数和尾数，Rust初始实现未复现该逻辑。

修复后的Rust代码 #

/// Represents a number in standard form.
///
/// The `Standardform` struct holds the significand (mantissa) of the number
/// and an exponent that determines the power of 10 by which the significand should be multiplied.
#[derive(Debug, PartialEq)]
pub struct StandardForm {
    mantissa: f64,
    exponent: i8,
}

impl StandardForm {
    /// Creates a new instance of StandardForm with the given mantissa and exponent
    pub fn new(mantissa: f64, exponent: i8) -> Self {
        // 复现C++构造函数的初始默认值与顺序逻辑
        let mut instance = Self {
            mantissa: 1.0,
            exponent: 1,
        };

        if instance.in_range() {
            instance.exponent = exponent;
            instance.mantissa = mantissa;
        } else {
            instance.mantissa = mantissa;
            instance.exponent = exponent;
        }

        instance.adjust();
        instance
    }

    fn in_range(&self) -> bool {
        (self.mantissa >= 1.0 && self.mantissa <= 10.0)
            || (self.mantissa >= -10.0 && self.mantissa <= -1.0)
    }

    fn adjust(&mut self) {
        // 计算整体数值：mantissa * 10^exponent
        let value = self.mantissa * 10.0f64.powf(self.exponent as f64);

        if value == 0.0 {
            self.mantissa = 0.0;
            self.exponent = 0;
            return;
        }

        let abs_value = value.abs();
        let log10_abs = abs_value.log10();
        // 计算标准化后的指数
        let mut exponent = log10_abs.floor() as i8;
        let mut mantissa = value / 10.0f64.powf(exponent as f64);

        // 确保尾数在[1,10)或(-10,-1]范围内，处理浮点数精度边界
        match mantissa {
            m if m >= 10.0 => {
                mantissa /= 10.0;
                exponent += 1;
            }
            m if m <= -10.0 => {
                mantissa /= 10.0;
                exponent += 1;
            }
            m if m > 0.0 && m < 1.0 => {
                mantissa *= 10.0;
                exponent -= 1;
            }
            m if m < 0.0 && m > -1.0 => {
                mantissa *= 10.0;
                exponent -= 1;
            }
            _ => {}
        }

        self.mantissa = mantissa;
        self.exponent = exponent;
    }
}

修复说明 #

1. 整体数值标准化：先计算mantissa * 10^exponent的实际值，再对该值进行标准化，确保结果符合1 ≤ |mantissa| < 10的标准形式要求。
2. 保留符号：移除了强制转正负尾数的逻辑，直接保留原始数值的符号。
3. 复现C++初始化顺序：先使用默认值创建实例，再按C++的逻辑顺序设置指数和尾数，确保初始化行为一致。
4. 边界处理：增加了对浮点数精度边界的判断，避免因计算误差导致尾数超出范围。

内容的提问来源于stack exchange，提问作者Aarav Shah