swift映射范围:无法在合理的时间内键入check此表达式

Question

我想将一个范围映射到一个数组中。swift编译器5.2表示，它太复杂，无法进行类型检查。它看起来不应该是；这看起来很简单。我曾尝试在常量和映射结果上添加显式类型，但除了冗长和丑陋之外，这并没有帮助。是否可以强制编译器对此进行类型检查(基本上不放弃(？swift真的不会打字检查这个吗？为什么会这样？我该怎么办？代码如下。这是一个回复。谢谢你的帮助。

let p = [0.0, 1.0, 0.0, 0.0, 0.0]
let pExact = 0.8
let pOvershoot = 0.1
let pUndershoot = 0.1
func move(_ p: [Double], _ U: Int) -> [Double] {
let n = p.count
let q: [Double] = (0...n-1).map {i in 
p[(i - (U + 1) + n) % n] * pUndershoot 
+ p[(i - U + n)       % n] * pExact 
+ p[(i - (U - 1) + n) % n] * pOvershoot
}
return q
}
print(move(p, 1))

所以更多的信息，似乎与范围图有关。我可以取出其他逻辑，它编译并运行良好。

let p = [0.0, 1.0, 0.0, 0.0, 0.0]
let pExact = 0.8
let pOvershoot = 0.1
let pUndershoot = 0.1
let n = p.count
let i = 1
let U = 1
let q = p[(i - (U + 1) + n) % n] * pUndershoot 
+ p[(i - U + n)       % n] * pExact 
+ p[(i - (U - 1) + n) % n] * pOvershoot

print(q)

Answer 1

我不知道为什么编译器在这里进行类型推理时遇到问题，但键入闭包参数就足以修复它：

let p = [0.0, 1.0, 0.0, 0.0, 0.0]
let pExact = 0.8
let pOvershoot = 0.1
let pUndershoot = 0.1
func move(_ p: [Double], _ U: Int) -> [Double] {
let n = p.count
let q: [Double] = (0...n-1).map { (i: Int) in 
p[(i - (U + 1) + n) % n] * pUndershoot 
+ p[(i - U + n)       % n] * pExact 
+ p[(i - (U - 1) + n) % n] * pOvershoot
}
return q
}
print(move(p, 1))

Answer 2

Swift在+方面遇到问题。我根本不建议这样做，但如果你不使用它来消除歧义，你可以使用隐式键入。

infix operator ➕: AdditionPrecedence
extension Double {
static func ➕ (_ double0: Self, _ double1: Self) -> Self {
double0 + double1
}
}
func move(_ p: [Double], _ U: Int) -> [Double] {
let n = p.count
let q = (0...n-1).map { i in
p[(i - (U + 1) + n) % n] * pUndershoot
➕ p[(i - U + n)       % n] * pExact
➕ p[(i - (U - 1) + n) % n] * pOvershoot
}
return q
}

如其他答案所示，显式类型是最快的修复方法。但是Accelerate甚至只是SIMD可能更适合您的问题。

import simd
func move(_ p: [Double], _ U: Int) -> [Double] {
let n = p.count
return (0..<n).map { i in
dot(
SIMD3(
(-1...1).map { p[(i - (U + $0) + n) % n] }
),
[pUndershoot, pExact, pOvershoot]
)
}
}

Answer 3

好的，一旦我明白是映射函数不明确，我就在参数中添加了一个类型说明符；lambda取一个Int并返回一个Double(i:Int) -> Double。这是正确编译和运行的；

let p = [0.0, 1.0, 0.0, 0.0, 0.0]
let pExact = 0.8
let pOvershoot = 0.1
let pUndershoot = 0.1
func move(_ p: [Double], _ U: Int) -> [Double] {
let n = p.count
let q: [Double] = (0...(n-1)).map {(i:Int) -> Double in 
p[(i - (U + 1) + n) % n] * pUndershoot 
+ p[(i - U + n)       % n] * pExact 
+ p[(i - (U - 1) + n) % n] * pOvershoot
}
return q
}
print(move(p, 1))