Question

我需要像这样实现经验过滤器

0至2年
2+至4年

如何在快速范围内表达？

问题是我不能表达超过2到4年。虽然我可以做不到上限。例如像这样

let underTen = 0.0..<10.0

我需要这样的东西（大于下限）

let uptoTwo = 0.0...2.0
let twoPlus = 2.0>..4.0  // compiler error

目前我在做

let twoPlus = 2.1...4.0

但这并不完美。

Answer 1

来自nextUp协议的

FloatingPoint

您可以使用Double的{{3}}属性，在Double符合的nextUp中进行蓝图打印

<强>下个视频

比较大于此值的最不可表示的值。

对于任何有限值x，x.nextUp大于x。 ...

即：

let uptoTwo = 0.0...2.0
let twoPlus = 2.0.nextUp...4.0

FloatingPoint协议中已蓝图的属性FloatingPoint protocol已在您的问题的评论中提及。对于大多数数字，这是self与下一个更大的可表示数字之间的差异：

<强> ULP

最后一个地方的单位。

这是有效数字中最低有效数字的单位   self。对于大多数数字x，这是x和nextUp之间的差异   下一个更大的（数量级）可表示的数字。 ...

实际上，

self会返回ulp的值，并添加nextup。因此，对于上面的示例，以下内容是等效的（而在此用例中，imo，let uptoTwo = 0.0...2.0 let twoPlus = (2.0+2.0.ulp)...4.0应该是首选）。

twoPlus

您可能还需要考虑使用前一个upperBound范围的uptoTwo属性替换let uptoTwo = 0.0...2.0 // [0, 2] closed-closed let twoPlus = uptoTwo.upperBound.nextUp...4.0 // (2, 4] open-closed if uptoTwo.overlaps(twoPlus) { print("the two ranges overlap ...") } else { print("ranges are non-overlapping, ok!") } // ranges are non-overlapping, ok!中的下限文字：

'\0'

Answer 2

您可以改为创建一种方法来识别低于下限的值，而不是创建新类型的范围：

extension ClosedRange {
    func containsAboveLowerBound(value:Bound) -> Bool {
        if value > self.lowerBound {
            return self.contains(value)
        }
        else {
            return false
        }
    }
}

像这样实现它：

let r = 2.0...3.0
r.containsAboveLowerBound(value: 2.0) // false
r.containsAboveLowerBound(value: 2.01) // true

Answer 3

如果你的实际目的是使用范围进行过滤，那么如何将它们作为闭包呢？

let underTen = {0.0 <= $0 && $0 < 10.0}
let upToTwo = {0.0 <= $0 && $0 <= 2.0}
let twoPlus = {2.0 <  $0 && $0 <= 4.0}

你可以使用这样的过滤闭包：

class Client: CustomStringConvertible {
    var experience: Double
    init(experience: Double) {self.experience = experience}
    var description: String {return "Client(\(experience))"}
}
let clients = [Client(experience: 1.0),Client(experience: 2.0),Client(experience: 3.0)]
let filteredUnderTen = clients.filter {underTen($0.experience)}
print(filteredUnderTen) //->[Client(1.0), Client(2.0), Client(3.0)]
let filteredUpToTwo = clients.filter {upToTwo($0.experience)}
print(filteredUpToTwo) //->[Client(1.0), Client(2.0)]
let filteredTwoPlus = clients.filter {twoPlus($0.experience)}
print(filteredTwoPlus) //->[Client(3.0)]

Answer 4

我认为这样做，

extension ClosedRange where Bound == Int {
    func containsExclusiveOfBounds(_ bound: Bound) -> Bool {
        return !(bound == lowerBound || bound == upperBound)
    }
}

快速范围大于下限

4 个答案: