如何将浮点数转换为平衡三进制？求Swift逆函数实现

我已经实现了Swift函数convertFL2BT，可将由'-'、'0'、'+'组成的平衡三进制字符串转换为双精度浮点数。现在需要实现它的逆函数convertFL2BT，完成浮点数到对应平衡三进制字符串的转换。

已有基础代码与方法 #

原平衡三进制转浮点数函数 #

public static func convertBT2FL(ternaryString: String) -> Double {
    var exp : Double = 0
    var sum : Double = 0
    
    for trit in ternaryString {
        var tritN : Double = 0
        if trit == "+" {
            tritN = 1
        } else if trit == "0" {
            tritN = 0
        } else if trit == "-" {
            tritN = -1
        }
        sum += tritN * pow(3.0, exp)
        exp -= 1
    }
    
    return sum
}

数值归一化方法 #

已掌握将浮点数归一化到[-1.5, 1.5]区间的方法，代码如下：

var n = ceil((log(abs(significandValueDouble)) - log(1.5)) / log(3))
var newSignificand = significandValueDouble / pow(3.0, n)

逆函数convertFL2BT实现 #

核心逻辑是：先处理特殊值（0），然后对非零值进行归一化，接着迭代计算每一位三进制数位（trit），直到数值足够接近0或者达到指定精度，最后拼接符号位和数位并调整格式。

完整实现代码：

public static func convertFL2BT(doubleValue: Double) -> String {
    // 处理0的特殊情况
    guard doubleValue != 0 else {
        return "0"
    }
    
    var value = doubleValue
    var trits = [Character]()
    var exponent: Int = 0
    
    // 归一化到[-1.5, 1.5]区间
    let absValue = abs(value)
    let n = ceil((log(absValue) - log(1.5)) / log(3))
    exponent = Int(n)
    value /= pow(3.0, n)
    
    // 设置精度阈值，避免无限循环
    let precision = 1e-15
    var iterationCount = 0
    let maxIterations = 100 // 防止极端情况无限循环
    
    while abs(value) > precision && iterationCount < maxIterations {
        var trit: Character
        let scaled = value * 3.0
        
        if scaled > 0.5 {
            trit = "+"
            value = scaled - 1.0
        } else if scaled < -0.5 {
            trit = "-"
            value = scaled + 1.0
        } else {
            trit = "0"
            value = scaled
        }
        
        trits.append(trit)
        iterationCount += 1
    }
    
    // 处理符号与指数，拼接最终字符串
    var result = ""
    // 先添加整数部分的trit（归一化后的第一位对应3^exponent）
    result.append(trits.removeFirst())
    // 添加小数点（如果有小数部分）
    if !trits.isEmpty {
        result.append(".")
        result.append(contentsOf: trits)
    }
    
    // 处理指数部分（如果指数不为0）
    if exponent != 0 {
        result.append("e\(exponent)")
    }
    
    return result
}

逻辑说明 #

1. 特殊值处理：直接返回"0"避免后续计算错误。
2. 归一化：将数值缩放到[-1.5,1.5]，确定最高位的指数。
3. 迭代计算trit：每次将当前值乘以3，根据结果判断当前位是'+'、'-'还是'0'，同时调整剩余数值（减去/加上1或保持不变），直到数值足够小或达到迭代上限。
4. 格式拼接：将计算出的trits拼接成字符串，添加小数点和指数标识，得到符合要求的平衡三进制表示。

内容的提问来源于stack exchange，提问作者Jacob Jackson