mirror of
https://github.com/apple/swift-algorithms
synced 2026-11-22 04:10:39 +00:00
Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
eb93e564d4 | ||
|
|
11fda519ef |
No files matched your search
@@ -235,3 +235,61 @@ extension Sequence {
|
||||
return randomSample(count: k, using: &g)
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// randomElement()
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// This method is a single-element specialization of `randomSample(count:)`,
|
||||
// and extends the stdlib's `randomElement()` functionality (which is available
|
||||
// for collections) down to sequences.
|
||||
|
||||
extension Sequence {
|
||||
/// Randomly selects an element from this sequence, using the given generator
|
||||
/// as the source of randomness.
|
||||
///
|
||||
/// - Parameter rng: The random number generator to use for sampling.
|
||||
/// - Returns: A random element. If the sequence has no elements, this method
|
||||
/// returns `nil`.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the sequence.
|
||||
@inlinable
|
||||
public func randomElement<G: RandomNumberGenerator>(
|
||||
using rng: inout G
|
||||
) -> Element? {
|
||||
var iterator = makeIterator()
|
||||
guard var result = iterator.next() else {
|
||||
return nil
|
||||
}
|
||||
|
||||
var w = 1.0
|
||||
while true {
|
||||
w *= nextW(k: 1, using: &rng)
|
||||
var offset = nextOffset(w: w, using: &rng)
|
||||
while offset > 0, let _ = iterator.next() {
|
||||
offset -= 1
|
||||
}
|
||||
guard let nextElement = iterator.next()
|
||||
else { break }
|
||||
|
||||
result = nextElement
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
/// Randomly selects an element from this sequence.
|
||||
///
|
||||
/// This method is equivalent to calling `randomSample(using:)`, passing in
|
||||
/// the system's default random generator.
|
||||
///
|
||||
/// - Returns: A random element. If the sequence has no elements, this method
|
||||
/// returns `nil`.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the sequence.
|
||||
@inlinable
|
||||
public func randomElement() -> Element? {
|
||||
var g = SystemRandomNumberGenerator()
|
||||
return randomElement(using: &g)
|
||||
}
|
||||
}
|
||||
@@ -12,13 +12,17 @@
|
||||
import XCTest
|
||||
@testable import Algorithms
|
||||
|
||||
func expectedRange(for value: Int) -> ClosedRange<Int> {
|
||||
((value / 3) * 2) ... ((value / 3) * 4)
|
||||
}
|
||||
|
||||
func validateRandomSamples<S: Sequence>(
|
||||
_ samples: [Int: Int],
|
||||
elements: S,
|
||||
expectedValue: Int,
|
||||
file: StaticString = #file, line: UInt = #line
|
||||
) where S.Element == Int {
|
||||
let expectedRange = ((expectedValue / 3) * 2) ... ((expectedValue / 3) * 4)
|
||||
let expectedRange = expectedRange(for: expectedValue)
|
||||
XCTAssertEqualSequences(samples.keys.sorted(), elements,
|
||||
file: file, line: line)
|
||||
for v in samples.values {
|
||||
@@ -28,41 +32,44 @@ func validateRandomSamples<S: Sequence>(
|
||||
|
||||
private let n = 100
|
||||
private let k = 12
|
||||
private let iterations = 10_000
|
||||
private let iterations = 1000
|
||||
|
||||
/// A collection to sample from.
|
||||
private let c = 0..<n
|
||||
/// A sequence to sample from.
|
||||
private let s = sequence(first: 0, next: { $0 == n - 1 ? nil : $0 + 1 })
|
||||
/// An empty sequence
|
||||
private let emptySequence = sequence(state: 0, next: { (_) -> Int? in nil })
|
||||
|
||||
final class RandomSampleTests: XCTestCase {
|
||||
func testRandomStableSampleCollection() {
|
||||
let samples: [Int: Int] = (0..<iterations).reduce(into: [:]) { result, _ in
|
||||
let sample = c.randomStableSample(count: k)
|
||||
XCTAssert(sample.isSorted())
|
||||
for x in sample {
|
||||
result[x, default: 0] += 1
|
||||
}
|
||||
result.merge(sample.frequencies, uniquingKeysWith: +)
|
||||
}
|
||||
validateRandomSamples(samples, elements: c, expectedValue: (k * iterations) / n)
|
||||
}
|
||||
|
||||
func testRandomSampleCollection() {
|
||||
let samples: [Int: Int] = (0..<iterations).reduce(into: [:]) { result, _ in
|
||||
for x in c.randomSample(count: k) {
|
||||
result[x, default: 0] += 1
|
||||
}
|
||||
result.merge(c.randomSample(count: k).frequencies, uniquingKeysWith: +)
|
||||
}
|
||||
validateRandomSamples(samples, elements: c, expectedValue: (k * iterations) / n)
|
||||
}
|
||||
|
||||
func testRandomSampleSequence() {
|
||||
let samples: [Int: Int] = (0..<iterations).reduce(into: [:]) { result, _ in
|
||||
for x in s.randomSample(count: k) {
|
||||
result[x, default: 0] += 1
|
||||
}
|
||||
result.merge(s.randomSample(count: k).frequencies, uniquingKeysWith: +)
|
||||
}
|
||||
validateRandomSamples(samples, elements: s, expectedValue: (k * iterations) / n)
|
||||
}
|
||||
|
||||
func testRandomSampleEdgeCases() {
|
||||
XCTAssert(emptySequence.randomSample(count: 10).isEmpty)
|
||||
XCTAssert(([] as [Int]).randomSample(count: 10).isEmpty)
|
||||
XCTAssert(([] as [Int]).randomStableSample(count: 10).isEmpty)
|
||||
|
||||
XCTAssert(c.randomStableSample(count: 0).isEmpty)
|
||||
XCTAssertEqualSequences(c.randomStableSample(count: n), c)
|
||||
XCTAssertEqualSequences(c.randomStableSample(count: n * 2), c)
|
||||
@@ -77,21 +84,23 @@ final class RandomSampleTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testRandomSampleRepeatable() {
|
||||
var generator = SplitMix64(seed: 0)
|
||||
let seed = UInt64.random(in: 0 ... .max)
|
||||
|
||||
var generator = SplitMix64(seed: seed)
|
||||
let sample1a = c.randomSample(count: k, using: &generator)
|
||||
generator = SplitMix64(seed: 0)
|
||||
generator = SplitMix64(seed: seed)
|
||||
let sample2a = c.randomSample(count: k, using: &generator)
|
||||
XCTAssertEqual(sample1a, sample2a)
|
||||
|
||||
generator = SplitMix64(seed: 0)
|
||||
generator = SplitMix64(seed: seed)
|
||||
let sample1b = s.randomSample(count: k, using: &generator)
|
||||
generator = SplitMix64(seed: 0)
|
||||
generator = SplitMix64(seed: seed)
|
||||
let sample2b = s.randomSample(count: k, using: &generator)
|
||||
XCTAssertEqual(sample1b, sample2b)
|
||||
|
||||
generator = SplitMix64(seed: 0)
|
||||
generator = SplitMix64(seed: seed)
|
||||
let sample1c = c.randomStableSample(count: k, using: &generator)
|
||||
generator = SplitMix64(seed: 0)
|
||||
generator = SplitMix64(seed: seed)
|
||||
let sample2c = c.randomStableSample(count: k, using: &generator)
|
||||
XCTAssertEqual(sample1c, sample2c)
|
||||
}
|
||||
@@ -123,4 +132,37 @@ final class RandomSampleTests: XCTestCase {
|
||||
almostAllZero = AlmostAllZeroGenerator(seed: 0)
|
||||
_ = c.randomSample(count: k, using: &almostAllZero) // must not crash
|
||||
}
|
||||
|
||||
func testSequenceRandomElement() {
|
||||
XCTAssertNil(emptySequence.randomElement())
|
||||
|
||||
let expectedRange = expectedRange(for: iterations)
|
||||
let randomElements = (0..<(n*iterations)).map { _ in
|
||||
s.randomElement()!
|
||||
}.frequencies
|
||||
XCTAssertEqual(randomElements.count, n)
|
||||
XCTAssert(randomElements.values.allSatisfy { expectedRange.contains($0) })
|
||||
|
||||
let oneElementSequence = sequence(first: 0, next: { _ in nil })
|
||||
let randomOneElement = (0..<iterations).map { _ in
|
||||
oneElementSequence.randomElement()!
|
||||
}
|
||||
XCTAssert(randomOneElement.allSatisfy { $0 == 0 })
|
||||
|
||||
let twoElementSequence = sequence(state: [1, 2].makeIterator(), next: { $0.next() })
|
||||
let randomTwoElement = (0..<(2*iterations)).map { _ in
|
||||
twoElementSequence.randomElement()!
|
||||
}.frequencies
|
||||
XCTAssertEqual(randomTwoElement.count, 2)
|
||||
XCTAssert(randomElements.values.allSatisfy { expectedRange.contains($0) })
|
||||
}
|
||||
|
||||
func testSequenceRandomElementRepeatable() {
|
||||
let seed = UInt64.random(in: 0 ... .max)
|
||||
var generator = SplitMix64(seed: seed)
|
||||
let elements1 = (0..<500).map { _ in s.randomElement(using: &generator)! }
|
||||
generator = SplitMix64(seed: seed)
|
||||
let elements2 = (0..<500).map { _ in s.randomElement(using: &generator)! }
|
||||
XCTAssertEqual(elements1, elements2)
|
||||
}
|
||||
}
|
||||
@@ -23,6 +23,12 @@ extension Sequence where Element: Comparable {
|
||||
}
|
||||
}
|
||||
|
||||
extension Sequence where Element: Hashable {
|
||||
var frequencies: [Element: Int] {
|
||||
reduce(into: [:]) { $0[$1, default: 0] += 1 }
|
||||
}
|
||||
}
|
||||
|
||||
extension Numeric {
|
||||
func factorial() -> Self {
|
||||
guard self != 0 else { return 1 }
|
||||
|
||||
Reference in new issue
Block a user