选项1

我遇到的问题是，当我的循环中发生转换时，我会丢失一些信息，特别是，如果调用以下函数：

func factors(number: Double) -> [Double] {
    var result = [Double]()
    var divisor = 0.1

    let temporaryIncreasedNumber = Int(number) * 10

        while number > divisor {
            let theNewDivisor = divisor * 10
            print("\(divisor) * \(10) = \(theNewDivisor) for \(divisor), \(temporaryIncreasedNumber) % \(Int(theNewDivisor)) is \(temporaryIncreasedNumber % Int(theNewDivisor))")
            if temporaryIncreasedNumber % Int(theNewDivisor)  == 0 {
                //print ("dividing \(temporaryIncreasedNumber) by \(theNewDivisor) for \(divisor)")
                result.append(divisor);
            }

            divisor += 0.1
        }
    return result
}

20，所以：

factors(number: 20.0))

如果我在输出中查找示例：

1.1 * 10 = 11.0 for 1.1, 200 % 10 is 0

当我进行操作200 % Int(1.1 * 10)时，Int(1.1 * 10)给了我一个10而不是11，我不知道为什么？这当然会通过A % B == 0的验证，但不应该因为200 % 11 = 2

我在Playground中手动执行了以下操作，但这样运行正常并且给了我200 % 11 = 2的结果

let myX = 20.0
let myY = 1.1
let myCalc = Int(myX * 10.0) % Int(myY * 10.0)
let myCalc2 = 200 % 11

选项2

或者，如果我只是简单的事情并且仅使用双打操作，我仍然会得到不一致的值。如果我将代码简化为：

func factors(number: Double) -> [Double] {
    var result = [Double]()
    var divisor = 0.1

        while number > divisor {
            let whole = (number/divisor).rounded(.towardZero)
            print ("reminder of \(number) by \(divisor) = \((number/divisor) - whole)")
            if (number/divisor) - whole  == 0.0 {
                result.append(divisor);
            }

            divisor = divisor + 0.1
        }
    return result
}

factors(number: 20.0)

请注意我没有明确使用截断提醒，以便我可以检查出错了。

看一下以下操作，它会产生意想不到的结果：

reminder of 20.0 by 0.8 = 3.5527136788005e-15

但如果我在操场上手动执行以下操作：

let test = (20.0/0.8) - (20.0/0.8).rounded(.towardZero)

结果是0！

为什么while循环中的行为不同？我的代码中有什么问题吗？

Answer 1

直接联系Apple后，他们建议问题是因为铸造Int - ＆gt;双倍，反之亦然。在回复中......

浮点是基于二进制的，因此1.1并不是理想值 1 1/10，它是1.09999 ......，而1.1 * 10.0真的是10.999 ...... Double-to-Int转换截断

如果您需要进一步的精度，他们建议使用Decimal。我通过使用Decimal和NSDecimalNumber操作的组合以这种方式找到了解决方案（这样我就可以提取小数的两倍来对其进行舍入）。

func factors2(number: Double) -> [Decimal] {
    var result = [Decimal]()
    var divisor = Decimal(0.1)

    let decimalNumber = Decimal(number)

        while decimalNumber >= divisor {

            let operation = (decimalNumber/divisor)
            let wholeDecimal = NSDecimalNumber(decimal: operation)
            let whole = wholeDecimal.doubleValue.rounded(.towardZero)
            print ("reminder of \(decimalNumber) by \(divisor) = \((decimalNumber/divisor) - Decimal(whole))")
            if (decimalNumber/divisor) - Decimal(whole)  == 0.0 {
                result.append(divisor);
            }

            divisor += 0.1
        }
    return result
}

print(factors2(number: 20.0))

此解决方案提供正确的输出。在该示例中，十进制因子20.0（计数形式0.1至20.0）是：

[0.1, 0.2, 0.4, 0.5, 0.8, 1, 2, 2.5, 4, 5, 10, 20]

在while循环中余数运算符％的意外结果 - Swift

选项1

选项2

1 个答案: