mirror of
https://github.com/apple/swift-algorithms
synced 2026-11-22 04:10:39 +00:00
Compare commits
1
Commits
1.0.0
...
swift-format
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
993b950250 |
No files matched your search
@@ -0,0 +1,54 @@
|
||||
{
|
||||
"fileScopedDeclarationPrivacy" : {
|
||||
"accessLevel" : "private"
|
||||
},
|
||||
"indentation" : {
|
||||
"spaces" : 2
|
||||
},
|
||||
"indentConditionalCompilationBlocks" : true,
|
||||
"indentSwitchCaseLabels" : false,
|
||||
"lineBreakAroundMultilineExpressionChainComponents" : false,
|
||||
"lineBreakBeforeControlFlowKeywords" : false,
|
||||
"lineBreakBeforeEachArgument" : false,
|
||||
"lineBreakBeforeEachGenericRequirement" : false,
|
||||
"lineLength" : 100,
|
||||
"maximumBlankLines" : 1,
|
||||
"prioritizeKeepingFunctionOutputTogether" : false,
|
||||
"respectsExistingLineBreaks" : true,
|
||||
"rules" : {
|
||||
"AllPublicDeclarationsHaveDocumentation" : false,
|
||||
"AlwaysUseLowerCamelCase" : true,
|
||||
"AmbiguousTrailingClosureOverload" : true,
|
||||
"BeginDocumentationCommentWithOneLineSummary" : true,
|
||||
"DoNotUseSemicolons" : true,
|
||||
"DontRepeatTypeInStaticProperties" : true,
|
||||
"FileScopedDeclarationPrivacy" : true,
|
||||
"FullyIndirectEnum" : true,
|
||||
"GroupNumericLiterals" : true,
|
||||
"IdentifiersMustBeASCII" : true,
|
||||
"NeverForceUnwrap" : false,
|
||||
"NeverUseForceTry" : false,
|
||||
"NeverUseImplicitlyUnwrappedOptionals" : false,
|
||||
"NoAccessLevelOnExtensionDeclaration" : true,
|
||||
"NoBlockComments" : true,
|
||||
"NoCasesWithOnlyFallthrough" : true,
|
||||
"NoEmptyTrailingClosureParentheses" : true,
|
||||
"NoLabelsInCasePatterns" : true,
|
||||
"NoLeadingUnderscores" : false,
|
||||
"NoParensAroundConditions" : true,
|
||||
"NoVoidReturnOnFunctionSignature" : true,
|
||||
"OneCasePerLine" : true,
|
||||
"OneVariableDeclarationPerLine" : true,
|
||||
"OnlyOneTrailingClosureArgument" : true,
|
||||
"OrderedImports" : true,
|
||||
"ReturnVoidInsteadOfEmptyTuple" : true,
|
||||
"UseLetInEveryBoundCaseVariable" : true,
|
||||
"UseShorthandTypeNames" : true,
|
||||
"UseSingleLinePropertyGetter" : true,
|
||||
"UseSynthesizedInitializer" : true,
|
||||
"UseTripleSlashForDocumentationComments" : true,
|
||||
"ValidateDocumentationComments" : false
|
||||
},
|
||||
"tabWidth" : 8,
|
||||
"version" : 1
|
||||
}
|
||||
+19
-19
@@ -13,23 +13,23 @@
|
||||
import PackageDescription
|
||||
|
||||
let package = Package(
|
||||
name: "swift-algorithms",
|
||||
products: [
|
||||
.library(
|
||||
name: "Algorithms",
|
||||
targets: ["Algorithms"]),
|
||||
],
|
||||
dependencies: [
|
||||
.package(url: "https://github.com/apple/swift-numerics", from: "0.0.1"),
|
||||
],
|
||||
targets: [
|
||||
.target(
|
||||
name: "Algorithms",
|
||||
dependencies: [
|
||||
.product(name: "RealModule", package: "swift-numerics"),
|
||||
]),
|
||||
.testTarget(
|
||||
name: "SwiftAlgorithmsTests",
|
||||
dependencies: ["Algorithms"]),
|
||||
]
|
||||
name: "swift-algorithms",
|
||||
products: [
|
||||
.library(
|
||||
name: "Algorithms",
|
||||
targets: ["Algorithms"])
|
||||
],
|
||||
dependencies: [
|
||||
.package(url: "https://github.com/apple/swift-numerics", from: "0.0.1")
|
||||
],
|
||||
targets: [
|
||||
.target(
|
||||
name: "Algorithms",
|
||||
dependencies: [
|
||||
.product(name: "RealModule", package: "swift-numerics")
|
||||
]),
|
||||
.testTarget(
|
||||
name: "SwiftAlgorithmsTests",
|
||||
dependencies: ["Algorithms"]),
|
||||
]
|
||||
)
|
||||
@@ -11,12 +11,11 @@
|
||||
|
||||
/// A concatenation of two sequences with the same element type.
|
||||
public struct Chain2<Base1: Sequence, Base2: Sequence>
|
||||
where Base1.Element == Base2.Element
|
||||
{
|
||||
where Base1.Element == Base2.Element {
|
||||
/// The first sequence in this chain.
|
||||
@usableFromInline
|
||||
internal let base1: Base1
|
||||
|
||||
|
||||
/// The second sequence in this chain.
|
||||
@usableFromInline
|
||||
internal let base2: Base2
|
||||
@@ -33,22 +32,22 @@ extension Chain2: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var iterator1: Base1.Iterator
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var iterator2: Base2.Iterator
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(_ concatenation: Chain2) {
|
||||
iterator1 = concatenation.base1.makeIterator()
|
||||
iterator2 = concatenation.base2.makeIterator()
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Base1.Element? {
|
||||
return iterator1.next() ?? iterator2.next()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(self)
|
||||
@@ -64,7 +63,7 @@ extension Chain2: Collection where Base1: Collection, Base2: Collection {
|
||||
// from the penultimate index of the first collection to the start of the
|
||||
// second.
|
||||
@usableFromInline
|
||||
internal enum Representation : Equatable {
|
||||
internal enum Representation: Equatable {
|
||||
case first(Base1.Index)
|
||||
case second(Base2.Index)
|
||||
}
|
||||
@@ -98,7 +97,7 @@ extension Chain2: Collection where Base1: Collection, Base2: Collection {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// Converts an index of `Base1` to the corresponding `Index` by mapping
|
||||
/// `base1.endIndex` to `base2.startIndex`.
|
||||
@inlinable
|
||||
@@ -138,16 +137,16 @@ extension Chain2: Collection where Base1: Collection, Base2: Collection {
|
||||
return Index(second: base2.index(after: i))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
guard distance != 0 else { return i }
|
||||
|
||||
|
||||
return distance > 0
|
||||
? offsetForward(i, by: distance)
|
||||
: offsetBackward(i, by: -distance)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ i: Index,
|
||||
@@ -168,14 +167,14 @@ extension Chain2: Collection where Base1: Collection, Base2: Collection {
|
||||
@inlinable
|
||||
internal func offsetForward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetForward(i, by: distance, limitedBy: endIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetBackward(i, by: distance, limitedBy: startIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
@@ -185,12 +184,12 @@ extension Chain2: Collection where Base1: Collection, Base2: Collection {
|
||||
) -> Index? {
|
||||
assert(distance >= 0)
|
||||
assert(limit >= i)
|
||||
|
||||
|
||||
switch (i.position, limit.position) {
|
||||
case let (.first(i), .first(limit)):
|
||||
return base1.index(i, offsetBy: distance, limitedBy: limit)
|
||||
.map(Index.init(first:))
|
||||
|
||||
|
||||
case let (.first(i), .second(limit)):
|
||||
if let j = base1.index(i, offsetBy: distance, limitedBy: base1.endIndex) {
|
||||
// the offset stays within the bounds of `base1`
|
||||
@@ -201,11 +200,11 @@ extension Chain2: Collection where Base1: Collection, Base2: Collection {
|
||||
return base2.index(base2.startIndex, offsetBy: distance - d, limitedBy: limit)
|
||||
.map(Index.init(second:))
|
||||
}
|
||||
|
||||
|
||||
case (.second, .first):
|
||||
// impossible because `limit >= i`
|
||||
fatalError()
|
||||
|
||||
|
||||
case let (.second(i), .second(limit)):
|
||||
return base2.index(i, offsetBy: distance, limitedBy: limit)
|
||||
.map(Index.init(second:))
|
||||
@@ -218,16 +217,16 @@ extension Chain2: Collection where Base1: Collection, Base2: Collection {
|
||||
) -> Index? {
|
||||
assert(distance >= 0)
|
||||
assert(limit <= i)
|
||||
|
||||
|
||||
switch (i.position, limit.position) {
|
||||
case let (.first(i), .first(limit)):
|
||||
return base1.index(i, offsetBy: -distance, limitedBy: limit)
|
||||
.map(Index.init(first:))
|
||||
|
||||
|
||||
case (.first, .second):
|
||||
// impossible because `limit <= i`
|
||||
fatalError()
|
||||
|
||||
|
||||
case let (.second(i), .first(limit)):
|
||||
if let j = base2.index(i, offsetBy: -distance, limitedBy: base2.startIndex) {
|
||||
// the offset stays within the bounds of `base2`
|
||||
@@ -245,7 +244,7 @@ extension Chain2: Collection where Base1: Collection, Base2: Collection {
|
||||
.map(Index.init(second:))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
switch (start.position, end.position) {
|
||||
@@ -264,8 +263,7 @@ extension Chain2: Collection where Base1: Collection, Base2: Collection {
|
||||
}
|
||||
|
||||
extension Chain2: BidirectionalCollection
|
||||
where Base1: BidirectionalCollection, Base2: BidirectionalCollection
|
||||
{
|
||||
where Base1: BidirectionalCollection, Base2: BidirectionalCollection {
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
assert(i != startIndex, "Can't advance before startIndex")
|
||||
@@ -281,7 +279,7 @@ extension Chain2: BidirectionalCollection
|
||||
}
|
||||
|
||||
extension Chain2: RandomAccessCollection
|
||||
where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
|
||||
where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// chain(_:_:)
|
||||
@@ -326,8 +324,7 @@ public typealias Chain = Chain2
|
||||
extension Sequence {
|
||||
@available(*, deprecated, message: "Use the chain(_:_:) function, instead.")
|
||||
public func chained<S: Sequence>(with other: S) -> Chain2<Self, S>
|
||||
where Element == S.Element
|
||||
{
|
||||
where Element == S.Element {
|
||||
Chain2(base1: self, base2: other)
|
||||
}
|
||||
}
|
||||
@@ -15,19 +15,19 @@ public struct Chunked<Base: Collection, Subject> {
|
||||
/// The collection that this instance provides a view onto.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
/// The projection function.
|
||||
@usableFromInline
|
||||
internal let projection: (Base.Element) -> Subject
|
||||
|
||||
|
||||
/// The predicate.
|
||||
@usableFromInline
|
||||
internal let belongInSameGroup: (Subject, Subject) -> Bool
|
||||
|
||||
|
||||
/// The upper bound of the first chunk.
|
||||
@usableFromInline
|
||||
internal var firstUpperBound: Base.Index
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base,
|
||||
@@ -38,7 +38,7 @@ public struct Chunked<Base: Collection, Subject> {
|
||||
self.projection = projection
|
||||
self.belongInSameGroup = belongInSameGroup
|
||||
self.firstUpperBound = base.startIndex
|
||||
|
||||
|
||||
if !base.isEmpty {
|
||||
firstUpperBound = endOfChunk(startingAt: base.startIndex)
|
||||
}
|
||||
@@ -51,19 +51,19 @@ extension Chunked: LazyCollectionProtocol {
|
||||
/// The range corresponding to the chunk at this position.
|
||||
@usableFromInline
|
||||
internal var baseRange: Range<Base.Index>
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(_ baseRange: Range<Base.Index>) {
|
||||
self.baseRange = baseRange
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Index, rhs: Index) -> Bool {
|
||||
// Since each index represents the range of a disparate chunk, no two
|
||||
// unique indices will have the same lower bound.
|
||||
lhs.baseRange.lowerBound == rhs.baseRange.lowerBound
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Index, rhs: Index) -> Bool {
|
||||
// Only use the lower bound to test for ordering, as above.
|
||||
@@ -79,17 +79,17 @@ extension Chunked: LazyCollectionProtocol {
|
||||
return base[base.index(after: start)...]
|
||||
.endOfPrefix(while: { belongInSameGroup(subject, projection($0)) })
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(base.startIndex..<firstUpperBound)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(base.endIndex..<base.endIndex)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i != endIndex, "Can't advance past endIndex")
|
||||
@@ -98,7 +98,7 @@ extension Chunked: LazyCollectionProtocol {
|
||||
let end = endOfChunk(startingAt: upperBound)
|
||||
return Index(upperBound..<end)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> Base.SubSequence {
|
||||
precondition(position != endIndex, "Can't subscript using endIndex")
|
||||
@@ -109,14 +109,13 @@ extension Chunked: LazyCollectionProtocol {
|
||||
extension Chunked.Index: Hashable where Base.Index: Hashable {}
|
||||
|
||||
extension Chunked: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
where Base: BidirectionalCollection {
|
||||
/// Returns the index in the base collection of the start of the chunk ending
|
||||
/// at the given index.
|
||||
@inlinable
|
||||
internal func startOfChunk(endingAt end: Base.Index) -> Base.Index {
|
||||
let indexBeforeEnd = base.index(before: end)
|
||||
|
||||
|
||||
// Get the projected value of the last element in the range ending at `end`.
|
||||
let subject = projection(base[indexBeforeEnd])
|
||||
return base[..<indexBeforeEnd]
|
||||
@@ -152,7 +151,7 @@ extension LazyCollectionProtocol {
|
||||
projection: { $0 },
|
||||
belongInSameGroup: belongInSameGroup)
|
||||
}
|
||||
|
||||
|
||||
/// Returns a lazy collection of subsequences of this collection, chunked by
|
||||
/// grouping elements that project to the same value.
|
||||
///
|
||||
@@ -185,10 +184,10 @@ extension Collection {
|
||||
) rethrows -> [SubSequence] {
|
||||
guard !isEmpty else { return [] }
|
||||
var result: [SubSequence] = []
|
||||
|
||||
|
||||
var start = startIndex
|
||||
var subject = try projection(self[start])
|
||||
|
||||
|
||||
for (index, element) in indexed().dropFirst() {
|
||||
let nextSubject = try projection(element)
|
||||
if try !belongInSameGroup(subject, nextSubject) {
|
||||
@@ -197,14 +196,14 @@ extension Collection {
|
||||
subject = nextSubject
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if start != endIndex {
|
||||
result.append(self[start..<endIndex])
|
||||
}
|
||||
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
|
||||
/// Returns a collection of subsequences of this collection, chunked by
|
||||
/// the given predicate.
|
||||
///
|
||||
@@ -242,15 +241,15 @@ extension Collection {
|
||||
/// * `c.chunks(ofCount: 3).map(f)` maps eagerly and returns a new array
|
||||
/// * `c.lazy.chunks(ofCount: 3).map(f)` maps lazily and returns a `LazyMapCollection`
|
||||
public struct ChunkedByCount<Base: Collection> {
|
||||
|
||||
|
||||
public typealias Element = Base.SubSequence
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let chunkCount: Int
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var startUpperBound: Base.Index
|
||||
|
||||
@@ -262,13 +261,14 @@ public struct ChunkedByCount<Base: Collection> {
|
||||
internal init(_base: Base, _chunkCount: Int) {
|
||||
self.base = _base
|
||||
self.chunkCount = _chunkCount
|
||||
|
||||
|
||||
// Compute the start index upfront in order to make
|
||||
// start index a O(1) lookup.
|
||||
self.startUpperBound = _base.index(
|
||||
_base.startIndex, offsetBy: _chunkCount,
|
||||
limitedBy: _base.endIndex
|
||||
) ?? _base.endIndex
|
||||
self.startUpperBound =
|
||||
_base.index(
|
||||
_base.startIndex, offsetBy: _chunkCount,
|
||||
limitedBy: _base.endIndex
|
||||
) ?? _base.endIndex
|
||||
}
|
||||
}
|
||||
|
||||
@@ -276,7 +276,7 @@ extension ChunkedByCount: Collection {
|
||||
public struct Index {
|
||||
@usableFromInline
|
||||
internal let baseRange: Range<Base.Index>
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(_baseRange: Range<Base.Index>) {
|
||||
self.baseRange = _baseRange
|
||||
@@ -292,35 +292,40 @@ extension ChunkedByCount: Collection {
|
||||
public var endIndex: Index {
|
||||
Index(_baseRange: base.endIndex..<base.endIndex)
|
||||
}
|
||||
|
||||
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public subscript(i: Index) -> Element {
|
||||
precondition(i < endIndex, "Index out of range")
|
||||
return base[i.baseRange]
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i < endIndex, "Advancing past end index")
|
||||
let baseIdx = base.index(
|
||||
i.baseRange.upperBound, offsetBy: chunkCount,
|
||||
limitedBy: base.endIndex
|
||||
) ?? base.endIndex
|
||||
let baseIdx =
|
||||
base.index(
|
||||
i.baseRange.upperBound, offsetBy: chunkCount,
|
||||
limitedBy: base.endIndex
|
||||
) ?? base.endIndex
|
||||
return Index(_baseRange: i.baseRange.upperBound..<baseIdx)
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunkedByCount.Index: Comparable {
|
||||
@inlinable
|
||||
public static func == (lhs: ChunkedByCount.Index,
|
||||
rhs: ChunkedByCount.Index) -> Bool {
|
||||
public static func == (
|
||||
lhs: ChunkedByCount.Index,
|
||||
rhs: ChunkedByCount.Index
|
||||
) -> Bool {
|
||||
lhs.baseRange.lowerBound == rhs.baseRange.lowerBound
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: ChunkedByCount.Index,
|
||||
rhs: ChunkedByCount.Index) -> Bool {
|
||||
public static func < (
|
||||
lhs: ChunkedByCount.Index,
|
||||
rhs: ChunkedByCount.Index
|
||||
) -> Bool {
|
||||
lhs.baseRange.lowerBound < rhs.baseRange.lowerBound
|
||||
}
|
||||
}
|
||||
@@ -331,19 +336,20 @@ where Base: RandomAccessCollection {
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i > startIndex, "Advancing past start index")
|
||||
|
||||
|
||||
var offset = chunkCount
|
||||
if i.baseRange.lowerBound == base.endIndex {
|
||||
let remainder = base.count%chunkCount
|
||||
let remainder = base.count % chunkCount
|
||||
if remainder != 0 {
|
||||
offset = remainder
|
||||
}
|
||||
}
|
||||
|
||||
let baseIdx = base.index(
|
||||
i.baseRange.lowerBound, offsetBy: -offset,
|
||||
limitedBy: base.startIndex
|
||||
) ?? base.startIndex
|
||||
|
||||
let baseIdx =
|
||||
base.index(
|
||||
i.baseRange.lowerBound, offsetBy: -offset,
|
||||
limitedBy: base.startIndex
|
||||
) ?? base.startIndex
|
||||
return Index(_baseRange: baseIdx..<i.baseRange.lowerBound)
|
||||
}
|
||||
}
|
||||
@@ -352,8 +358,9 @@ extension ChunkedByCount {
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
let distance =
|
||||
base.distance(from: start.baseRange.lowerBound,
|
||||
to: end.baseRange.lowerBound)
|
||||
base.distance(
|
||||
from: start.baseRange.lowerBound,
|
||||
to: end.baseRange.lowerBound)
|
||||
let (quotient, remainder) =
|
||||
distance.quotientAndRemainder(dividingBy: chunkCount)
|
||||
return quotient + remainder.signum()
|
||||
@@ -365,14 +372,14 @@ extension ChunkedByCount {
|
||||
base.count.quotientAndRemainder(dividingBy: chunkCount)
|
||||
return quotient + remainder.signum()
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ i: Index, offsetBy offset: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
guard offset != 0 else { return i }
|
||||
guard limit != i else { return nil }
|
||||
|
||||
|
||||
if offset > 0 {
|
||||
return limit > i
|
||||
? offsetForward(i, offsetBy: offset, limit: limit)
|
||||
@@ -387,16 +394,17 @@ extension ChunkedByCount {
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
guard distance != 0 else { return i }
|
||||
|
||||
let idx = distance > 0
|
||||
? offsetForward(i, offsetBy: distance)
|
||||
: offsetBackward(i, offsetBy: distance)
|
||||
|
||||
let idx =
|
||||
distance > 0
|
||||
? offsetForward(i, offsetBy: distance)
|
||||
: offsetBackward(i, offsetBy: distance)
|
||||
guard let index = idx else {
|
||||
fatalError("Out of bounds")
|
||||
}
|
||||
return index
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(
|
||||
_ i: Index, offsetBy distance: Int, limit: Index? = nil
|
||||
@@ -409,14 +417,14 @@ extension ChunkedByCount {
|
||||
limit: limit, by: >
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
// Convenience to compute offset backward base distance.
|
||||
@inlinable
|
||||
internal func computeOffsetBackwardBaseDistance(
|
||||
_ i: Index, _ distance: Int
|
||||
) -> Int {
|
||||
if i == endIndex {
|
||||
let remainder = base.count%chunkCount
|
||||
let remainder = base.count % chunkCount
|
||||
// We have to take it into account when calculating offsets.
|
||||
if remainder != 0 {
|
||||
// Distance "minus" one(at this point distance is negative)
|
||||
@@ -427,21 +435,21 @@ extension ChunkedByCount {
|
||||
}
|
||||
return distance * chunkCount
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ i: Index, offsetBy distance: Int, limit: Index? = nil
|
||||
) -> Index? {
|
||||
assert(distance < 0)
|
||||
let baseDistance =
|
||||
computeOffsetBackwardBaseDistance(i, distance)
|
||||
computeOffsetBackwardBaseDistance(i, distance)
|
||||
return makeOffsetIndex(
|
||||
from: i, baseBound: base.startIndex,
|
||||
distance: distance, baseDistance: baseDistance,
|
||||
limit: limit, by: <
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
// Helper to compute index(offsetBy:) index.
|
||||
@inlinable
|
||||
internal func makeOffsetIndex(
|
||||
@@ -452,7 +460,7 @@ extension ChunkedByCount {
|
||||
i.baseRange.lowerBound, offsetBy: baseDistance,
|
||||
limitedBy: baseBound
|
||||
)
|
||||
|
||||
|
||||
if let limit = limit {
|
||||
if baseIdx == nil {
|
||||
// If we past the bounds while advancing forward and the
|
||||
@@ -478,12 +486,13 @@ extension ChunkedByCount {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
let baseStartIdx = baseIdx ?? baseBound
|
||||
let baseEndIdx = base.index(
|
||||
baseStartIdx, offsetBy: chunkCount, limitedBy: base.endIndex
|
||||
) ?? base.endIndex
|
||||
|
||||
let baseEndIdx =
|
||||
base.index(
|
||||
baseStartIdx, offsetBy: chunkCount, limitedBy: base.endIndex
|
||||
) ?? base.endIndex
|
||||
|
||||
return Index(_baseRange: baseStartIdx..<baseEndIdx)
|
||||
}
|
||||
}
|
||||
@@ -516,6 +525,6 @@ extension ChunkedByCount.Index: Hashable where Base.Index: Hashable {}
|
||||
|
||||
// Lazy conditional conformance.
|
||||
extension ChunkedByCount: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension ChunkedByCount: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
where Base: LazyCollectionProtocol {}
|
||||
@@ -14,16 +14,16 @@ public struct Combinations<Base: Collection> {
|
||||
/// The collection to iterate over for combinations.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let baseCount: Int
|
||||
|
||||
|
||||
/// The range of accepted sizes of combinations.
|
||||
/// - Note: This may be `nil` if the attempted range entirely exceeds the
|
||||
/// upper bounds of the size of the `base` collection.
|
||||
@usableFromInline
|
||||
internal let kRange: Range<Int>?
|
||||
|
||||
|
||||
/// Initializes a `Combinations` for all combinations of `base` of size `k`.
|
||||
/// - Parameters:
|
||||
/// - base: The collection to iterate over for combinations.
|
||||
@@ -32,7 +32,7 @@ public struct Combinations<Base: Collection> {
|
||||
internal init(_ base: Base, k: Int) {
|
||||
self.init(base, kRange: k...k)
|
||||
}
|
||||
|
||||
|
||||
/// Initializes a `Combinations` for all combinations of `base` of sizes
|
||||
/// within a given range.
|
||||
/// - Parameters:
|
||||
@@ -47,20 +47,21 @@ public struct Combinations<Base: Collection> {
|
||||
let baseCount = base.count
|
||||
self.baseCount = baseCount
|
||||
let upperBound = baseCount + 1
|
||||
self.kRange = range.lowerBound < upperBound
|
||||
? range.clamped(to: 0 ..< upperBound)
|
||||
self.kRange =
|
||||
range.lowerBound < upperBound
|
||||
? range.clamped(to: 0..<upperBound)
|
||||
: nil
|
||||
}
|
||||
|
||||
|
||||
/// The total number of combinations.
|
||||
@inlinable
|
||||
public var count: Int {
|
||||
guard let k = self.kRange else { return 0 }
|
||||
let n = baseCount
|
||||
if k == 0 ..< (n + 1) {
|
||||
if k == 0..<(n + 1) {
|
||||
return 1 << n
|
||||
}
|
||||
|
||||
|
||||
func binomial(n: Int, k: Int) -> Int {
|
||||
switch k {
|
||||
case n, 0: return 1
|
||||
@@ -69,7 +70,7 @@ public struct Combinations<Base: Collection> {
|
||||
default: return n * binomial(n: n - 1, k: k - 1) / k
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return k.map {
|
||||
binomial(n: n, k: $0)
|
||||
}.reduce(0, +)
|
||||
@@ -81,30 +82,30 @@ extension Combinations: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
/// The current range of accepted sizes of combinations.
|
||||
/// - Note: The range is contracted until empty while iterating over
|
||||
/// combinations of different sizes. When the range is empty, iteration is
|
||||
/// finished.
|
||||
@usableFromInline
|
||||
internal var kRange: Range<Int>
|
||||
|
||||
|
||||
/// Whether or not iteration is finished (`kRange` is empty)
|
||||
@inlinable
|
||||
internal var isFinished: Bool {
|
||||
return kRange.isEmpty
|
||||
}
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var indexes: [Base.Index]
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(_ combinations: Combinations) {
|
||||
self.base = combinations.base
|
||||
self.kRange = combinations.kRange ?? 0..<0
|
||||
self.indexes = Array(combinations.base.indices.prefix(kRange.lowerBound))
|
||||
}
|
||||
|
||||
|
||||
/// Advances the current indices to the next set of combinations. If
|
||||
/// `indexes.count == 3` and `base.count == 5`, the indices advance like
|
||||
/// this:
|
||||
@@ -130,12 +131,12 @@ extension Combinations: Sequence {
|
||||
func advanceKRange() {
|
||||
if kRange.lowerBound < kRange.upperBound {
|
||||
let advancedLowerBound = kRange.lowerBound + 1
|
||||
kRange = advancedLowerBound ..< kRange.upperBound
|
||||
kRange = advancedLowerBound..<kRange.upperBound
|
||||
indexes.removeAll(keepingCapacity: true)
|
||||
indexes.append(contentsOf: base.indices.prefix(kRange.lowerBound))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
guard !indexes.isEmpty else {
|
||||
// Initial state for combinations of 0 elements is an empty array with
|
||||
// `finished == false`. Even though no indexes are involved, advancing
|
||||
@@ -143,11 +144,11 @@ extension Combinations: Sequence {
|
||||
advanceKRange()
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
let i = indexes.count - 1
|
||||
base.formIndex(after: &indexes[i])
|
||||
if indexes[i] != base.endIndex { return }
|
||||
|
||||
|
||||
var j = i
|
||||
while indexes[i] == base.endIndex {
|
||||
j -= 1
|
||||
@@ -156,7 +157,7 @@ extension Combinations: Sequence {
|
||||
advanceKRange()
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
base.formIndex(after: &indexes[j])
|
||||
for k in indexes.indices[(j + 1)...] {
|
||||
indexes[k] = base.index(after: indexes[k - 1])
|
||||
@@ -166,7 +167,7 @@ extension Combinations: Sequence {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> [Base.Element]? {
|
||||
guard !isFinished else { return nil }
|
||||
@@ -174,7 +175,7 @@ extension Combinations: Sequence {
|
||||
return indexes.map { i in base[i] }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(self)
|
||||
}
|
||||
@@ -254,7 +255,7 @@ extension Collection {
|
||||
) -> Combinations<Self> where R.Bound == Int {
|
||||
return Combinations(self, kRange: kRange)
|
||||
}
|
||||
|
||||
|
||||
/// Returns a collection of combinations of this collection's elements, with
|
||||
/// each combination having the specified number of elements.
|
||||
///
|
||||
|
||||
@@ -11,11 +11,11 @@
|
||||
|
||||
/// A `Sequence` that iterates over every non-nil element from the original `Sequence`.
|
||||
public struct CompactedSequence<Base: Sequence, Element>: Sequence
|
||||
where Base.Element == Element? {
|
||||
where Base.Element == Element? {
|
||||
|
||||
@usableFromInline
|
||||
let base: Base
|
||||
|
||||
|
||||
@inlinable
|
||||
init(base: Base) {
|
||||
self.base = base
|
||||
@@ -24,12 +24,12 @@ public struct CompactedSequence<Base: Sequence, Element>: Sequence
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
var base: Base.Iterator
|
||||
|
||||
|
||||
@inlinable
|
||||
init(base: Base.Iterator) {
|
||||
self.base = base
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Element? {
|
||||
while let wrapped = base.next() {
|
||||
@@ -66,81 +66,84 @@ extension Sequence {
|
||||
/// Complexity: O(1)
|
||||
@inlinable
|
||||
public func compacted<Unwrapped>() -> CompactedSequence<Self, Unwrapped>
|
||||
where Element == Unwrapped? {
|
||||
where Element == Unwrapped? {
|
||||
CompactedSequence(base: self)
|
||||
}
|
||||
}
|
||||
|
||||
/// A `Collection` that iterates over every non-nil element from the original `Collection`.
|
||||
public struct CompactedCollection<Base: Collection, Element>: Collection
|
||||
where Base.Element == Element? {
|
||||
where Base.Element == Element? {
|
||||
|
||||
@usableFromInline
|
||||
let base: Base
|
||||
|
||||
|
||||
@inlinable
|
||||
init(base: Base) {
|
||||
self.base = base
|
||||
let idx = base.firstIndex(where: { $0 != nil }) ?? base.endIndex
|
||||
self.startIndex = Index(base: idx)
|
||||
}
|
||||
|
||||
|
||||
public struct Index {
|
||||
@usableFromInline
|
||||
let base: Base.Index
|
||||
|
||||
|
||||
@inlinable
|
||||
init(base: Base.Index) {
|
||||
self.base = base
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public var startIndex: Index
|
||||
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index { Index(base: base.endIndex) }
|
||||
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> Element {
|
||||
base[position.base]!
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i != endIndex, "Index out of bounds")
|
||||
|
||||
|
||||
let baseIdx = base.index(after: i.base)
|
||||
guard let idx = base[baseIdx...].firstIndex(where: { $0 != nil })
|
||||
else { return endIndex }
|
||||
else { return endIndex }
|
||||
return Index(base: idx)
|
||||
}
|
||||
}
|
||||
|
||||
extension CompactedCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection {
|
||||
where Base: BidirectionalCollection {
|
||||
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i != startIndex, "Index out of bounds")
|
||||
|
||||
guard let idx =
|
||||
base[startIndex.base..<i.base]
|
||||
.lastIndex(where: { $0 != nil })
|
||||
else { fatalError("Index out of bounds") }
|
||||
|
||||
guard
|
||||
let idx =
|
||||
base[startIndex.base..<i.base]
|
||||
.lastIndex(where: { $0 != nil })
|
||||
else { fatalError("Index out of bounds") }
|
||||
return Index(base: idx)
|
||||
}
|
||||
}
|
||||
|
||||
extension CompactedCollection.Index: Comparable {
|
||||
extension CompactedCollection.Index: Comparable {
|
||||
@inlinable
|
||||
public static func < (lhs: CompactedCollection.Index,
|
||||
rhs: CompactedCollection.Index) -> Bool {
|
||||
public static func < (
|
||||
lhs: CompactedCollection.Index,
|
||||
rhs: CompactedCollection.Index
|
||||
) -> Bool {
|
||||
lhs.base < rhs.base
|
||||
}
|
||||
}
|
||||
|
||||
extension CompactedCollection.Index: Hashable
|
||||
where Base.Index: Hashable {}
|
||||
where Base.Index: Hashable {}
|
||||
|
||||
extension Collection {
|
||||
/// Returns a new `Collection` that iterates over every non-nil element
|
||||
@@ -163,7 +166,7 @@ extension Collection {
|
||||
/// original `Collection`.
|
||||
@inlinable
|
||||
public func compacted<Unwrapped>() -> CompactedCollection<Self, Unwrapped>
|
||||
where Element == Unwrapped? {
|
||||
where Element == Unwrapped? {
|
||||
CompactedCollection(base: self)
|
||||
}
|
||||
}
|
||||
@@ -173,9 +176,9 @@ extension Collection {
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension CompactedSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension CompactedCollection: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension CompactedCollection: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
where Base: LazyCollectionProtocol {}
|
||||
@@ -14,7 +14,7 @@ public struct Cycle<Base: Collection> {
|
||||
/// The collection to repeat.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base) {
|
||||
self.base = base
|
||||
@@ -26,29 +26,29 @@ extension Cycle: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var current: Base.Index
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base) {
|
||||
self.base = base
|
||||
self.current = base.startIndex
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Base.Element? {
|
||||
guard !base.isEmpty else { return nil }
|
||||
|
||||
|
||||
if current == base.endIndex {
|
||||
current = base.startIndex
|
||||
}
|
||||
|
||||
|
||||
defer { base.formIndex(after: ¤t) }
|
||||
return base[current]
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(base: base)
|
||||
@@ -57,7 +57,6 @@ extension Cycle: Sequence {
|
||||
|
||||
extension Cycle: LazySequenceProtocol where Base: LazySequenceProtocol {}
|
||||
|
||||
|
||||
/// A collection wrapper that repeats the elements of a base collection for a
|
||||
/// finite number of times.
|
||||
public struct FiniteCycle<Base: Collection> {
|
||||
@@ -72,7 +71,7 @@ public struct FiniteCycle<Base: Collection> {
|
||||
}
|
||||
|
||||
extension FiniteCycle: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol { }
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
extension FiniteCycle: Collection {
|
||||
|
||||
@@ -137,9 +136,12 @@ extension FiniteCycle: Collection {
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
guard let productIndex = product.index(i.productIndex,
|
||||
offsetBy: distance,
|
||||
limitedBy: limit.productIndex) else {
|
||||
guard
|
||||
let productIndex = product.index(
|
||||
i.productIndex,
|
||||
offsetBy: distance,
|
||||
limitedBy: limit.productIndex)
|
||||
else {
|
||||
return nil
|
||||
}
|
||||
return Index(productIndex)
|
||||
@@ -152,7 +154,7 @@ extension FiniteCycle: Collection {
|
||||
}
|
||||
|
||||
extension FiniteCycle: BidirectionalCollection
|
||||
where Base: BidirectionalCollection {
|
||||
where Base: BidirectionalCollection {
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
let productIndex = product.index(before: i.productIndex)
|
||||
@@ -161,7 +163,7 @@ extension FiniteCycle: BidirectionalCollection
|
||||
}
|
||||
|
||||
extension FiniteCycle: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// cycled()
|
||||
@@ -197,7 +199,7 @@ extension Collection {
|
||||
public func cycled() -> Cycle<Self> {
|
||||
Cycle(base: self)
|
||||
}
|
||||
|
||||
|
||||
/// Returns a sequence that repeats the elements of this collection the
|
||||
/// specified number of times.
|
||||
///
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
// firstNonNil(_:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
public extension Sequence {
|
||||
extension Sequence {
|
||||
/// Returns the first non-`nil` result obtained from applying the given
|
||||
/// transformation to the elements of the sequence.
|
||||
///
|
||||
@@ -30,7 +30,7 @@ public extension Sequence {
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the number of elements at the start of
|
||||
/// the sequence that result in `nil` when applying the transformation.
|
||||
func firstNonNil<Result>(
|
||||
public func firstNonNil<Result>(
|
||||
_ transform: (Element) throws -> Result?
|
||||
) rethrows -> Result? {
|
||||
for value in self {
|
||||
|
||||
@@ -14,11 +14,11 @@
|
||||
public struct Indexed<Base: Collection> {
|
||||
/// The element type for an `Indexed` collection.
|
||||
public typealias Element = (index: Base.Index, element: Base.Element)
|
||||
|
||||
|
||||
/// The base collection.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base) {
|
||||
self.base = base
|
||||
@@ -30,32 +30,34 @@ extension Indexed: Collection {
|
||||
public var startIndex: Base.Index {
|
||||
base.startIndex
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Base.Index {
|
||||
base.endIndex
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Base.Index) -> Element {
|
||||
(index: position, element: base[position])
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Base.Index) -> Base.Index {
|
||||
base.index(after: i)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Base.Index, offsetBy distance: Int) -> Base.Index {
|
||||
base.index(i, offsetBy: distance)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Base.Index, offsetBy distance: Int, limitedBy limit: Base.Index) -> Base.Index? {
|
||||
public func index(_ i: Base.Index, offsetBy distance: Int, limitedBy limit: Base.Index) -> Base
|
||||
.Index?
|
||||
{
|
||||
base.index(i, offsetBy: distance, limitedBy: limit)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Base.Index, to end: Base.Index) -> Int {
|
||||
base.distance(from: start, to: end)
|
||||
|
||||
@@ -14,10 +14,10 @@
|
||||
public struct Intersperse<Base: Sequence> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let separator: Base.Element
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, separator: Base.Element) {
|
||||
self.base = base
|
||||
@@ -30,19 +30,19 @@ extension Intersperse: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var iterator: Base.Iterator
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let separator: Base.Element
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var state = State.start
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(iterator: Base.Iterator, separator: Base.Element) {
|
||||
self.iterator = iterator
|
||||
self.separator = separator
|
||||
}
|
||||
|
||||
|
||||
@usableFromInline
|
||||
enum State {
|
||||
case start
|
||||
@@ -85,7 +85,7 @@ extension Intersperse: Collection where Base: Collection {
|
||||
case element(Base.Index)
|
||||
case separator(next: Base.Index)
|
||||
}
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let representation: Representation
|
||||
|
||||
@@ -98,14 +98,14 @@ extension Intersperse: Collection where Base: Collection {
|
||||
public static func < (lhs: Index, rhs: Index) -> Bool {
|
||||
switch (lhs.representation, rhs.representation) {
|
||||
case let (.element(li), .element(ri)),
|
||||
let (.separator(next: li), .separator(next: ri)),
|
||||
let (.element(li), .separator(next: ri)):
|
||||
let (.separator(next: li), .separator(next: ri)),
|
||||
let (.element(li), .separator(next: ri)):
|
||||
return li < ri
|
||||
case let (.separator(next: li), .element(ri)):
|
||||
return li <= ri
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
static func element(_ index: Base.Index) -> Self {
|
||||
Self(representation: .element(index))
|
||||
@@ -145,7 +145,7 @@ extension Intersperse: Collection where Base: Collection {
|
||||
case .separator: return separator
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
switch (i.representation, distance.isMultiple(of: 2)) {
|
||||
@@ -169,15 +169,14 @@ extension Intersperse: Collection where Base: Collection {
|
||||
case let (.separator(next: separator), .element(element)):
|
||||
return 2 * base.distance(from: separator, to: element) + 1
|
||||
case let (.element(start), .element(end)),
|
||||
let (.separator(start), .separator(end)):
|
||||
let (.separator(start), .separator(end)):
|
||||
return 2 * base.distance(from: start, to: end)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension Intersperse: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
where Base: BidirectionalCollection {
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i != startIndex, "Can't move before startIndex")
|
||||
@@ -191,13 +190,13 @@ extension Intersperse: BidirectionalCollection
|
||||
}
|
||||
|
||||
extension Intersperse: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension Intersperse: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension Intersperse: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
extension Sequence {
|
||||
|
||||
|
||||
@@ -17,20 +17,20 @@ extension Sequence {
|
||||
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> [Element] {
|
||||
var iterator = makeIterator()
|
||||
|
||||
|
||||
var result: [Element] = []
|
||||
result.reserveCapacity(count)
|
||||
while result.count < count, let e = iterator.next() {
|
||||
result.append(e)
|
||||
}
|
||||
try result.sort(by: areInIncreasingOrder)
|
||||
|
||||
|
||||
while let e = iterator.next() {
|
||||
// To be part of `result`, `e` must be strictly less than `result.last`.
|
||||
guard try areInIncreasingOrder(e, result.last!) else { continue }
|
||||
let insertionIndex =
|
||||
try result.partitioningIndex { try areInIncreasingOrder(e, $0) }
|
||||
|
||||
|
||||
assert(insertionIndex != result.endIndex)
|
||||
result.removeLast()
|
||||
result.insert(e, at: insertionIndex)
|
||||
@@ -38,7 +38,7 @@ extension Sequence {
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
|
||||
/// Implementation for max(count:areInIncreasingOrder:)
|
||||
@inlinable
|
||||
internal func _maxImplementation(
|
||||
@@ -46,14 +46,14 @@ extension Sequence {
|
||||
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> [Element] {
|
||||
var iterator = makeIterator()
|
||||
|
||||
|
||||
var result: [Element] = []
|
||||
result.reserveCapacity(count)
|
||||
while result.count < count, let e = iterator.next() {
|
||||
result.append(e)
|
||||
}
|
||||
try result.sort(by: areInIncreasingOrder)
|
||||
|
||||
|
||||
while let e = iterator.next() {
|
||||
// To be part of `result`, `e` must be greater/equal to `result.first`.
|
||||
guard try !areInIncreasingOrder(e, result.first!) else { continue }
|
||||
@@ -71,10 +71,10 @@ extension Sequence {
|
||||
}
|
||||
result[insertionIndex - 1] = e
|
||||
}
|
||||
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
|
||||
/// Returns the smallest elements of this sequence, as sorted by the given
|
||||
/// predicate.
|
||||
///
|
||||
@@ -107,7 +107,9 @@ extension Sequence {
|
||||
count: Int,
|
||||
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> [Element] {
|
||||
precondition(count >= 0, """
|
||||
precondition(
|
||||
count >= 0,
|
||||
"""
|
||||
Cannot find a minimum with a negative count of elements!
|
||||
"""
|
||||
)
|
||||
@@ -152,7 +154,9 @@ extension Sequence {
|
||||
count: Int,
|
||||
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> [Element] {
|
||||
precondition(count >= 0, """
|
||||
precondition(
|
||||
count >= 0,
|
||||
"""
|
||||
Cannot find a maximum with a negative count of elements!
|
||||
"""
|
||||
)
|
||||
@@ -253,7 +257,9 @@ extension Collection {
|
||||
count: Int,
|
||||
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> [Element] {
|
||||
precondition(count >= 0, """
|
||||
precondition(
|
||||
count >= 0,
|
||||
"""
|
||||
Cannot find a minimum with a negative count of elements!
|
||||
"""
|
||||
)
|
||||
@@ -271,7 +277,7 @@ extension Collection {
|
||||
guard prefixCount < (self.count / 10) else {
|
||||
return Array(try sorted(by: areInIncreasingOrder).prefix(prefixCount))
|
||||
}
|
||||
|
||||
|
||||
return try _minImplementation(count: count, sortedBy: areInIncreasingOrder)
|
||||
}
|
||||
|
||||
@@ -307,7 +313,9 @@ extension Collection {
|
||||
count: Int,
|
||||
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> [Element] {
|
||||
precondition(count >= 0, """
|
||||
precondition(
|
||||
count >= 0,
|
||||
"""
|
||||
Cannot find a maximum with a negative count of elements!
|
||||
"""
|
||||
)
|
||||
|
||||
@@ -25,7 +25,7 @@ extension MutableCollection {
|
||||
internal mutating func stablePartition(
|
||||
count n: Int,
|
||||
subrange: Range<Index>,
|
||||
by belongsInSecondPartition: (Element) throws-> Bool
|
||||
by belongsInSecondPartition: (Element) throws -> Bool
|
||||
) rethrows -> Index {
|
||||
if n == 0 { return subrange.lowerBound }
|
||||
if n == 1 {
|
||||
@@ -33,8 +33,9 @@ extension MutableCollection {
|
||||
? subrange.lowerBound
|
||||
: subrange.upperBound
|
||||
}
|
||||
|
||||
let h = n / 2, i = index(subrange.lowerBound, offsetBy: h)
|
||||
|
||||
let h = n / 2
|
||||
let i = index(subrange.lowerBound, offsetBy: h)
|
||||
let j = try stablePartition(
|
||||
count: h,
|
||||
subrange: subrange.lowerBound..<i,
|
||||
@@ -45,7 +46,7 @@ extension MutableCollection {
|
||||
by: belongsInSecondPartition)
|
||||
return rotate(subrange: j..<k, toStartAt: i)
|
||||
}
|
||||
|
||||
|
||||
/// Moves all elements satisfying the given predicate into a suffix of the
|
||||
/// given range, preserving the relative order of the elements in both
|
||||
/// partitions, and returns the start of the resulting suffix.
|
||||
@@ -60,14 +61,14 @@ extension MutableCollection {
|
||||
@inlinable
|
||||
public mutating func stablePartition(
|
||||
subrange: Range<Index>,
|
||||
by belongsInSecondPartition: (Element) throws-> Bool
|
||||
by belongsInSecondPartition: (Element) throws -> Bool
|
||||
) rethrows -> Index {
|
||||
try stablePartition(
|
||||
count: distance(from: subrange.lowerBound, to: subrange.upperBound),
|
||||
subrange: subrange,
|
||||
by: belongsInSecondPartition)
|
||||
}
|
||||
|
||||
|
||||
/// Moves all elements satisfying the given predicate into a suffix of this
|
||||
/// collection, preserving the relative order of the elements in both
|
||||
/// partitions, and returns the start of the resulting suffix.
|
||||
@@ -79,7 +80,7 @@ extension MutableCollection {
|
||||
/// - Complexity: O(*n* log *n*), where *n* is the length of this collection.
|
||||
@inlinable
|
||||
public mutating func stablePartition(
|
||||
by belongsInSecondPartition: (Element) throws-> Bool
|
||||
by belongsInSecondPartition: (Element) throws -> Bool
|
||||
) rethrows -> Index {
|
||||
try stablePartition(
|
||||
subrange: startIndex..<endIndex,
|
||||
@@ -104,8 +105,8 @@ extension MutableCollection {
|
||||
// This version of `partition(subrange:)` is half stable; the elements in
|
||||
// the first partition retain their original relative order.
|
||||
guard var i = try self[subrange].firstIndex(where: belongsInSecondPartition)
|
||||
else { return subrange.upperBound }
|
||||
|
||||
else { return subrange.upperBound }
|
||||
|
||||
var j = index(after: i)
|
||||
while j != subrange.upperBound {
|
||||
if try !belongsInSecondPartition(self[j]) {
|
||||
@@ -114,7 +115,7 @@ extension MutableCollection {
|
||||
}
|
||||
formIndex(after: &j)
|
||||
}
|
||||
|
||||
|
||||
return i
|
||||
}
|
||||
}
|
||||
@@ -189,7 +190,7 @@ extension Collection {
|
||||
) rethrows -> Index {
|
||||
var n = count
|
||||
var l = startIndex
|
||||
|
||||
|
||||
while n > 0 {
|
||||
let half = n / 2
|
||||
let mid = index(l, offsetBy: half)
|
||||
@@ -203,4 +204,3 @@ extension Collection {
|
||||
return l
|
||||
}
|
||||
}
|
||||
|
||||
@@ -14,8 +14,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension MutableCollection
|
||||
where Self: BidirectionalCollection, Element: Comparable
|
||||
{
|
||||
where Self: BidirectionalCollection, Element: Comparable {
|
||||
/// Permutes this collection's elements through all the lexical orderings.
|
||||
///
|
||||
/// Call `nextPermutation()` repeatedly starting with the collection in
|
||||
@@ -34,26 +33,26 @@ extension MutableCollection
|
||||
guard !isEmpty else { return false }
|
||||
var i = index(before: endIndex)
|
||||
if i == startIndex { return false }
|
||||
|
||||
|
||||
let upperBound = upperBound ?? endIndex
|
||||
|
||||
|
||||
while true {
|
||||
let ip1 = i
|
||||
formIndex(before: &i)
|
||||
|
||||
|
||||
// Find the last ascending pair (ie. ..., a, b, ... where a < b)
|
||||
if self[i] < self[ip1] {
|
||||
// Find the last element greater than self[i]
|
||||
// This is _always_ at most `ip1` due to if statement above
|
||||
let j = lastIndex(where: { self[i] < $0 })!
|
||||
|
||||
|
||||
// At this point we have something like this:
|
||||
// 0, 1, 4, 3, 2
|
||||
// ^ ^
|
||||
// i j
|
||||
swapAt(i, j)
|
||||
self.reverse(subrange: ip1 ..< endIndex)
|
||||
|
||||
self.reverse(subrange: ip1..<endIndex)
|
||||
|
||||
// Only return if we've made a change within ..<upperBound region
|
||||
if i < upperBound {
|
||||
return true
|
||||
@@ -62,7 +61,7 @@ extension MutableCollection
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if i == startIndex {
|
||||
self.reverse()
|
||||
return false
|
||||
@@ -80,16 +79,16 @@ public struct Permutations<Base: Collection> {
|
||||
/// The base collection to iterate over for permutations.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let baseCount: Int
|
||||
|
||||
|
||||
/// The range of accepted sizes of permutations.
|
||||
/// - Note: This may be empty if the attempted range entirely exceeds the
|
||||
/// bounds of the size of the `base` collection.
|
||||
@usableFromInline
|
||||
internal let kRange: Range<Int>
|
||||
|
||||
|
||||
/// Initializes a `Permutations` for all permutations of `base` of size `k`.
|
||||
/// - Parameters:
|
||||
/// - base: The collection to iterate over for permutations
|
||||
@@ -99,13 +98,13 @@ public struct Permutations<Base: Collection> {
|
||||
internal init(_ base: Base, k: Int? = nil) {
|
||||
let kRange: ClosedRange<Int>?
|
||||
if let countToChoose = k {
|
||||
kRange = countToChoose ... countToChoose
|
||||
kRange = countToChoose...countToChoose
|
||||
} else {
|
||||
kRange = nil
|
||||
}
|
||||
self.init(base, kRange: kRange)
|
||||
}
|
||||
|
||||
|
||||
/// Initializes a `Permutations` for all combinations of `base` of sizes
|
||||
/// within a given range.
|
||||
/// - Parameters:
|
||||
@@ -120,11 +119,11 @@ public struct Permutations<Base: Collection> {
|
||||
let baseCount = base.count
|
||||
self.baseCount = baseCount
|
||||
let upperBound = baseCount + 1
|
||||
self.kRange = kRange?.relative(to: 0 ..< .max)
|
||||
.clamped(to: 0 ..< upperBound) ??
|
||||
baseCount ..< upperBound
|
||||
self.kRange =
|
||||
kRange?.relative(to: 0 ..< .max)
|
||||
.clamped(to: 0..<upperBound) ?? baseCount..<upperBound
|
||||
}
|
||||
|
||||
|
||||
/// The total number of permutations.
|
||||
@inlinable
|
||||
public var count: Int {
|
||||
@@ -139,26 +138,26 @@ extension Permutations: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let baseCount: Int
|
||||
|
||||
|
||||
/// The current range of accepted sizes of permutations.
|
||||
/// - Note: The range is contracted until empty while iterating over
|
||||
/// permutations of different sizes. When the range is empty, iteration is
|
||||
/// finished.
|
||||
@usableFromInline
|
||||
internal var kRange: Range<Int>
|
||||
|
||||
|
||||
/// Whether or not iteration is finished (`kRange` is empty)
|
||||
@inlinable
|
||||
internal var isFinished: Bool {
|
||||
return kRange.isEmpty
|
||||
}
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var indexes: [Base.Index]
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(_ permutations: Permutations) {
|
||||
self.base = permutations.base
|
||||
@@ -166,7 +165,7 @@ extension Permutations: Sequence {
|
||||
self.kRange = permutations.kRange
|
||||
self.indexes = Array(permutations.base.indices)
|
||||
}
|
||||
|
||||
|
||||
/// Advances the `indexes` array such that the first `countToChoose`
|
||||
/// elements contain the next lexicographic ordering of elements.
|
||||
///
|
||||
@@ -182,44 +181,44 @@ extension Permutations: Sequence {
|
||||
internal mutating func nextState() -> Bool {
|
||||
let countToChoose = self.kRange.lowerBound
|
||||
let edge = countToChoose - 1
|
||||
|
||||
|
||||
// Find first index greater than the one at `edge`.
|
||||
if let i = indexes[countToChoose...].firstIndex(where: { indexes[edge] < $0 }) {
|
||||
indexes.swapAt(edge, i)
|
||||
} else {
|
||||
indexes.reverse(subrange: countToChoose ..< indexes.endIndex)
|
||||
|
||||
indexes.reverse(subrange: countToChoose..<indexes.endIndex)
|
||||
|
||||
// Find last increasing pair below `edge`.
|
||||
// TODO: This could be indexes[..<edge].adjacentPairs().lastIndex(where: ...)
|
||||
var lastAscent = edge - 1
|
||||
while (lastAscent >= 0 && indexes[lastAscent] >= indexes[lastAscent + 1]) {
|
||||
while lastAscent >= 0 && indexes[lastAscent] >= indexes[lastAscent + 1] {
|
||||
lastAscent -= 1
|
||||
}
|
||||
if lastAscent < 0 {
|
||||
return false
|
||||
}
|
||||
|
||||
|
||||
// Find rightmost index less than that at `lastAscent`.
|
||||
if let i = indexes[lastAscent...].lastIndex(where: { indexes[lastAscent] < $0 }) {
|
||||
indexes.swapAt(lastAscent, i)
|
||||
}
|
||||
indexes.reverse(subrange: (lastAscent + 1) ..< indexes.endIndex)
|
||||
indexes.reverse(subrange: (lastAscent + 1)..<indexes.endIndex)
|
||||
}
|
||||
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> [Base.Element]? {
|
||||
guard !isFinished else { return nil }
|
||||
|
||||
|
||||
/// Advances `kRange` by incrementing its `lowerBound` until the range is
|
||||
/// empty, when iteration is finished.
|
||||
func advanceKRange() {
|
||||
kRange.removeFirst()
|
||||
indexes = Array(base.indices)
|
||||
}
|
||||
|
||||
|
||||
let countToChoose = self.kRange.lowerBound
|
||||
if countToChoose == 0 {
|
||||
defer {
|
||||
@@ -227,7 +226,7 @@ extension Permutations: Sequence {
|
||||
}
|
||||
return []
|
||||
}
|
||||
|
||||
|
||||
let permutesFullCollection = (countToChoose == baseCount)
|
||||
if permutesFullCollection {
|
||||
// If we're permuting the full collection, each iteration is just a
|
||||
@@ -252,7 +251,7 @@ extension Permutations: Sequence {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(self)
|
||||
@@ -328,7 +327,7 @@ extension Collection {
|
||||
) -> Permutations<Self> where R.Bound == Int {
|
||||
return Permutations(self, kRange: kRange)
|
||||
}
|
||||
|
||||
|
||||
/// Returns a collection of the permutations of this collection of the
|
||||
/// specified length.
|
||||
///
|
||||
@@ -400,10 +399,10 @@ public struct UniquePermutations<Base: Collection> {
|
||||
/// The base collection to iterate over for permutations.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var indexes: [Base.Index]
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let kRange: Range<Int>
|
||||
}
|
||||
@@ -414,29 +413,28 @@ extension UniquePermutations where Base.Element: Hashable {
|
||||
let firstIndexesAndCountsByElement = Dictionary(
|
||||
base.indices.lazy.map { (base[$0], ($0, 1)) },
|
||||
uniquingKeysWith: { indexAndCount, _ in (indexAndCount.0, indexAndCount.1 + 1) })
|
||||
|
||||
|
||||
return firstIndexesAndCountsByElement
|
||||
.values.sorted(by: { $0.0 < $1.0 })
|
||||
.flatMap { index, count in repeatElement(index, count: count) }
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(_ elements: Base) {
|
||||
self.indexes = Self._indexes(elements)
|
||||
self.base = elements
|
||||
self.kRange = self.indexes.count ..< (self.indexes.count + 1)
|
||||
self.kRange = self.indexes.count..<(self.indexes.count + 1)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal init<R: RangeExpression>(_ base: Base, _ range: R)
|
||||
where R.Bound == Int
|
||||
{
|
||||
where R.Bound == Int {
|
||||
self.indexes = Self._indexes(base)
|
||||
self.base = base
|
||||
|
||||
|
||||
let upperBound = self.indexes.count + 1
|
||||
self.kRange = range.relative(to: 0 ..< .max)
|
||||
.clamped(to: 0 ..< upperBound)
|
||||
.clamped(to: 0..<upperBound)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -445,10 +443,10 @@ extension UniquePermutations: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var indexes: [Base.Index]
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var lengths: Range<Int>
|
||||
|
||||
@@ -461,14 +459,14 @@ extension UniquePermutations: Sequence {
|
||||
self.indexes = indexes
|
||||
self.lengths = lengths
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> [Base.Element]? {
|
||||
// In the end case, `lengths` is an empty range.
|
||||
if lengths.isEmpty {
|
||||
return nil
|
||||
}
|
||||
|
||||
|
||||
// The first iteration must produce the original sorted array, before any
|
||||
// permutations. We skip the permutation the first time so that we can
|
||||
// always mutate the array _before_ returning a slice, which avoids
|
||||
@@ -485,11 +483,11 @@ extension UniquePermutations: Sequence {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return indexes[..<lengths.lowerBound].map { base[$0] }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(base, indexes: indexes, lengths: kRange)
|
||||
@@ -539,7 +537,7 @@ extension Collection where Element: Hashable {
|
||||
/// collection.
|
||||
public func uniquePermutations(ofCount k: Int? = nil) -> UniquePermutations<Self> {
|
||||
if let k = k {
|
||||
return UniquePermutations(self, k ..< (k + 1))
|
||||
return UniquePermutations(self, k..<(k + 1))
|
||||
} else {
|
||||
return UniquePermutations(self)
|
||||
}
|
||||
@@ -575,8 +573,7 @@ extension Collection where Element: Hashable {
|
||||
/// - Complexity: O(*n*), where *n* is the number of elements in this
|
||||
/// collection.
|
||||
public func uniquePermutations<R: RangeExpression>(ofCount kRange: R) -> UniquePermutations<Self>
|
||||
where R.Bound == Int
|
||||
{
|
||||
where R.Bound == Int {
|
||||
UniquePermutations(self, kRange)
|
||||
}
|
||||
}
|
||||
@@ -14,11 +14,11 @@ public struct Product2<Base1: Sequence, Base2: Collection> {
|
||||
/// The outer sequence in the product.
|
||||
@usableFromInline
|
||||
internal let base1: Base1
|
||||
|
||||
|
||||
/// The inner sequence in the product.
|
||||
@usableFromInline
|
||||
internal let base2: Base2
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(_ base1: Base1, _ base2: Base2) {
|
||||
self.base1 = base1
|
||||
@@ -28,7 +28,7 @@ public struct Product2<Base1: Sequence, Base2: Collection> {
|
||||
|
||||
extension Product2: Sequence {
|
||||
public typealias Element = (Base1.Element, Base2.Element)
|
||||
|
||||
|
||||
/// The iterator for a `Product2` sequence.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
@@ -47,10 +47,12 @@ extension Product2: Sequence {
|
||||
self.i2 = c.base2.makeIterator()
|
||||
self.element1 = nil
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> (Base1.Element,
|
||||
Base2.Element)? {
|
||||
public mutating func next() -> (
|
||||
Base1.Element,
|
||||
Base2.Element
|
||||
)? {
|
||||
// This is the initial state, where i1.next() has never
|
||||
// been called, or the final state, where i1.next() has
|
||||
// already returned nil.
|
||||
@@ -59,21 +61,21 @@ extension Product2: Sequence {
|
||||
// once Base1 is exhausted, return `nil` forever
|
||||
if element1 == nil { return nil }
|
||||
}
|
||||
|
||||
|
||||
// Get the next element from the second sequence, if not
|
||||
// at end.
|
||||
if let element2 = i2.next() {
|
||||
return (element1!, element2)
|
||||
}
|
||||
|
||||
|
||||
// We've reached the end of the second sequence, so:
|
||||
// 1) Get the next element of the first sequence, if exists
|
||||
// 2) Restart iteration of the second sequence
|
||||
// 3) Get the first element of the second sequence, if exists
|
||||
element1 = i1.next()
|
||||
guard let element1 = element1
|
||||
else { return nil }
|
||||
|
||||
else { return nil }
|
||||
|
||||
i2 = base2.makeIterator()
|
||||
if let element2 = i2.next() {
|
||||
return (element1, element2)
|
||||
@@ -95,43 +97,45 @@ extension Product2: Collection where Base1: Collection {
|
||||
internal var i1: Base1.Index
|
||||
@usableFromInline
|
||||
internal var i2: Base2.Index
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(i1: Base1.Index, i2: Base2.Index) {
|
||||
self.i1 = i1
|
||||
self.i2 = i2
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Index, rhs: Index) -> Bool {
|
||||
(lhs.i1, lhs.i2) < (rhs.i1, rhs.i2)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var count: Int {
|
||||
base1.count * base2.count
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(
|
||||
i1: base2.isEmpty ? base1.endIndex : base1.startIndex,
|
||||
i2: base2.startIndex)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
// `base2.startIndex` simplifies index calculations.
|
||||
Index(i1: base1.endIndex, i2: base2.startIndex)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> (Base1.Element,
|
||||
Base2.Element) {
|
||||
public subscript(position: Index) -> (
|
||||
Base1.Element,
|
||||
Base2.Element
|
||||
) {
|
||||
(base1[position.i1], base2[position.i2])
|
||||
}
|
||||
|
||||
|
||||
/// Forms an index from a pair of base indices, normalizing
|
||||
/// `(i, base2.endIndex)` to `(base1.index(after: i), base2.startIndex)` if
|
||||
/// necessary.
|
||||
@@ -141,24 +145,24 @@ extension Product2: Collection where Base1: Collection {
|
||||
? Index(i1: base1.index(after: i1), i2: base2.startIndex)
|
||||
: Index(i1: i1, i2: i2)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i.i1 != base1.endIndex, "Can't advance past endIndex")
|
||||
return normalizeIndex(i.i1, base2.index(after: i.i2))
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
guard start.i1 <= end.i1
|
||||
else { return -distance(from: end, to: start) }
|
||||
else { return -distance(from: end, to: start) }
|
||||
guard start.i1 != end.i1
|
||||
else { return base2.distance(from: start.i2, to: end.i2) }
|
||||
|
||||
else { return base2.distance(from: start.i2, to: end.i2) }
|
||||
|
||||
// The number of full cycles through `base2` between `start` and `end`,
|
||||
// excluding the cycles that `start` and `end` are on.
|
||||
let fullBase2Cycles = base1[start.i1..<end.i1].count - 1
|
||||
|
||||
|
||||
if start.i2 <= end.i2 {
|
||||
// start.i2
|
||||
// v
|
||||
@@ -169,11 +173,11 @@ extension Product2: Collection where Base1: Collection {
|
||||
// end.i1 > [l l l c c c c c c|r r r]
|
||||
// ^
|
||||
// end.i2
|
||||
|
||||
|
||||
let left = base2[..<start.i2].count
|
||||
let center = base2[start.i2..<end.i2].count
|
||||
let right = base2[end.i2...].count
|
||||
|
||||
|
||||
return center + right
|
||||
+ fullBase2Cycles * (left + center + right)
|
||||
+ left + center
|
||||
@@ -187,30 +191,30 @@ extension Product2: Collection where Base1: Collection {
|
||||
// end.i1 > [l l l|c c c c c c r r r]
|
||||
// ^
|
||||
// end.i2
|
||||
|
||||
|
||||
let left = base2[..<end.i2].count
|
||||
let right = base2[start.i2...].count
|
||||
|
||||
|
||||
// We can avoid traversing `base2[end.i2..<start.i2]` if `start` and `end`
|
||||
// are on consecutive cycles.
|
||||
guard fullBase2Cycles > 0 else { return right + left }
|
||||
|
||||
|
||||
let center = base2[end.i2..<start.i2].count
|
||||
return right
|
||||
+ fullBase2Cycles * (left + center + right)
|
||||
+ left
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
guard distance != 0 else { return i }
|
||||
|
||||
|
||||
return distance > 0
|
||||
? offsetForward(i, by: distance)
|
||||
: offsetBackward(i, by: -distance)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ i: Index,
|
||||
@@ -231,36 +235,35 @@ extension Product2: Collection where Base1: Collection {
|
||||
@inlinable
|
||||
internal func offsetForward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetForward(i, by: distance, limitedBy: endIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetBackward(i, by: distance, limitedBy: startIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance >= 0)
|
||||
assert(limit >= i)
|
||||
|
||||
|
||||
if limit.i1 == i.i1 {
|
||||
// Delegate to `base2` if the offset is limited to `i.i1`.
|
||||
//
|
||||
// i.i2 limit.i2
|
||||
// v v
|
||||
// i.i1 > [x x x|x x x x x x|x x x]
|
||||
|
||||
|
||||
return base2.index(i.i2, offsetBy: distance, limitedBy: limit.i2)
|
||||
.map { i2 in Index(i1: i.i1, i2: i2) }
|
||||
}
|
||||
|
||||
|
||||
|
||||
if let i2 = base2.index(i.i2, offsetBy: distance, limitedBy: base2.endIndex) {
|
||||
// `distance` does not overflow `base2[i.i2...]`.
|
||||
//
|
||||
@@ -268,14 +271,14 @@ extension Product2: Collection where Base1: Collection {
|
||||
// v v
|
||||
// i.i1 > [x x x|x x x x x x|x x x]
|
||||
// [ |> > > > > >| ] (`distance`)
|
||||
|
||||
|
||||
return normalizeIndex(i.i1, i2)
|
||||
}
|
||||
|
||||
|
||||
let suffixCount = base2[i.i2...].count
|
||||
let remaining = distance - suffixCount
|
||||
let nextI1 = base1.index(after: i.i1)
|
||||
|
||||
|
||||
if limit.i1 == nextI1 {
|
||||
// Delegate to `base2` if the offset is limited to `nextI1`.
|
||||
//
|
||||
@@ -285,11 +288,11 @@ extension Product2: Collection where Base1: Collection {
|
||||
// nextI1 > [x x x x x x x x x|x x x]
|
||||
// ^
|
||||
// limit.i2
|
||||
|
||||
|
||||
return base2.index(base2.startIndex, offsetBy: remaining, limitedBy: limit.i2)
|
||||
.map { i2 in Index(i1: nextI1, i2: i2) }
|
||||
}
|
||||
|
||||
|
||||
if let i2 = base2.index(base2.startIndex, offsetBy: remaining, limitedBy: i.i2) {
|
||||
// `remaining` does not overflow `base2[..<i.i2]`.
|
||||
//
|
||||
@@ -301,20 +304,20 @@ extension Product2: Collection where Base1: Collection {
|
||||
// nextI1 > [x x x|x x x x x x x x x]
|
||||
// ^
|
||||
// i2
|
||||
|
||||
|
||||
return Index(i1: nextI1, i2: i2)
|
||||
}
|
||||
|
||||
|
||||
let prefixCount = base2[..<i.i2].count
|
||||
let base2Count = prefixCount + suffixCount
|
||||
let base1Distance = remaining / base2Count
|
||||
|
||||
|
||||
guard let i1 = base1.index(nextI1, offsetBy: base1Distance, limitedBy: limit.i1)
|
||||
else { return nil }
|
||||
|
||||
else { return nil }
|
||||
|
||||
// The distance from `base2.startIndex` to the target.
|
||||
let base2Distance = remaining % base2Count
|
||||
|
||||
|
||||
let base2Limit = limit.i1 == i1 ? limit.i2 : base2.endIndex
|
||||
return base2.index(base2.startIndex, offsetBy: base2Distance, limitedBy: base2Limit)
|
||||
.map { i2 in Index(i1: i1, i2: i2) }
|
||||
@@ -326,18 +329,18 @@ extension Product2: Collection where Base1: Collection {
|
||||
) -> Index? {
|
||||
assert(distance >= 0)
|
||||
assert(limit <= i)
|
||||
|
||||
|
||||
if limit.i1 == i.i1 {
|
||||
// Delegate to `base2` if the offset is limited to `i.i1`.
|
||||
//
|
||||
// limit.i2 i.i2
|
||||
// v v
|
||||
// i.i1 > [x x x|x x x x x x|x x x]
|
||||
|
||||
|
||||
return base2.index(i.i2, offsetBy: -distance, limitedBy: limit.i2)
|
||||
.map { i2 in Index(i1: i.i1, i2: i2) }
|
||||
}
|
||||
|
||||
|
||||
if let i2 = base2.index(i.i2, offsetBy: -distance, limitedBy: base2.startIndex) {
|
||||
// `distance` does not underflow `base2[..<i.i2]`.
|
||||
//
|
||||
@@ -345,14 +348,14 @@ extension Product2: Collection where Base1: Collection {
|
||||
// v v
|
||||
// i.i1 > [x x x|x x x x x x|x x x]
|
||||
// [ |< < < < < <| ] (`distance`)
|
||||
|
||||
|
||||
return Index(i1: i.i1, i2: i2)
|
||||
}
|
||||
|
||||
|
||||
let prefixCount = base2[..<i.i2].count
|
||||
let remaining = distance - prefixCount
|
||||
let previousI1 = base1.index(i.i1, offsetBy: -1)
|
||||
|
||||
|
||||
if limit.i1 == previousI1 {
|
||||
// Delegate to `base2` if the offset is limited to `previousI1`.
|
||||
//
|
||||
@@ -362,11 +365,11 @@ extension Product2: Collection where Base1: Collection {
|
||||
// i.i1 > [x x x x x x x x x|x x x]
|
||||
// ^
|
||||
// i.i2
|
||||
|
||||
|
||||
return base2.index(base2.endIndex, offsetBy: -remaining, limitedBy: limit.i2)
|
||||
.map { i2 in Index(i1: previousI1, i2: i2) }
|
||||
}
|
||||
|
||||
|
||||
if let i2 = base2.index(base2.endIndex, offsetBy: -remaining, limitedBy: i.i2) {
|
||||
// `remaining` does not underflow `base2[i.i2...]`.
|
||||
//
|
||||
@@ -378,17 +381,17 @@ extension Product2: Collection where Base1: Collection {
|
||||
// i.i1 > [x x x|x x x x x x x x x]
|
||||
// ^
|
||||
// i.i2
|
||||
|
||||
|
||||
return Index(i1: previousI1, i2: i2)
|
||||
}
|
||||
|
||||
|
||||
let suffixCount = base2[i.i2...].count
|
||||
let base2Count = prefixCount + suffixCount
|
||||
let base1Distance = remaining / base2Count
|
||||
|
||||
|
||||
// The distance from `base2.endIndex` to the target.
|
||||
let base2Distance = remaining % base2Count
|
||||
|
||||
|
||||
if base2Distance == 0 {
|
||||
// We end up exactly between two cycles, so `base1Distance` would
|
||||
// overshoot the target by 1.
|
||||
@@ -401,7 +404,7 @@ extension Product2: Collection where Base1: Collection {
|
||||
// i.i1 > [x x x|x x x x x x x x x]
|
||||
// ^
|
||||
// i.i2
|
||||
|
||||
|
||||
if let i1 = base1.index(previousI1, offsetBy: -(base1Distance - 1), limitedBy: limit.i1) {
|
||||
let index = Index(i1: i1, i2: base2.startIndex)
|
||||
return index < limit ? nil : index
|
||||
@@ -409,10 +412,10 @@ extension Product2: Collection where Base1: Collection {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
guard let i1 = base1.index(previousI1, offsetBy: -base1Distance, limitedBy: limit.i1)
|
||||
else { return nil }
|
||||
|
||||
else { return nil }
|
||||
|
||||
let base2Limit = limit.i1 == i1 ? limit.i2 : base2.startIndex
|
||||
return base2.index(base2.endIndex, offsetBy: -base2Distance, limitedBy: base2Limit)
|
||||
.map { i2 in Index(i1: i1, i2: i2) }
|
||||
@@ -420,12 +423,12 @@ extension Product2: Collection where Base1: Collection {
|
||||
}
|
||||
|
||||
extension Product2: BidirectionalCollection
|
||||
where Base1: BidirectionalCollection, Base2: BidirectionalCollection
|
||||
{
|
||||
where Base1: BidirectionalCollection, Base2: BidirectionalCollection {
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i != startIndex,
|
||||
"Can't move before startIndex")
|
||||
precondition(
|
||||
i != startIndex,
|
||||
"Can't move before startIndex")
|
||||
if i.i2 == base2.startIndex {
|
||||
return Index(
|
||||
i1: base1.index(before: i.i1),
|
||||
@@ -437,7 +440,7 @@ extension Product2: BidirectionalCollection
|
||||
}
|
||||
|
||||
extension Product2: RandomAccessCollection
|
||||
where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
|
||||
where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
|
||||
|
||||
extension Product2.Index: Hashable where Base1.Index: Hashable, Base2.Index: Hashable {}
|
||||
|
||||
|
||||
@@ -10,8 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// For log(_:) and root(_:_:)
|
||||
@_implementationOnly
|
||||
import RealModule
|
||||
@_implementationOnly import RealModule
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// randomStableSample(count:)
|
||||
@@ -33,13 +32,13 @@ extension Collection {
|
||||
count k: Int, using rng: inout G
|
||||
) -> [Element] {
|
||||
guard k > 0 else { return [] }
|
||||
|
||||
|
||||
var remainingCount = count
|
||||
guard k < remainingCount else { return Array(self) }
|
||||
|
||||
|
||||
var result: [Element] = []
|
||||
result.reserveCapacity(k)
|
||||
|
||||
|
||||
var i = startIndex
|
||||
var countToSelect = k
|
||||
while countToSelect > 0 {
|
||||
@@ -52,10 +51,10 @@ extension Collection {
|
||||
formIndex(after: &i)
|
||||
remainingCount -= 1
|
||||
}
|
||||
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
|
||||
/// Randomly selects the specified number of elements from this collection,
|
||||
/// maintaining their relative order.
|
||||
///
|
||||
@@ -120,22 +119,22 @@ extension Collection {
|
||||
var w = 1.0
|
||||
var result: [Element] = []
|
||||
result.reserveCapacity(k)
|
||||
|
||||
|
||||
// Fill the reservoir with the first `k` elements.
|
||||
var i = startIndex
|
||||
while i < endIndex, result.count < k {
|
||||
result.append(self[i])
|
||||
formIndex(after: &i)
|
||||
}
|
||||
|
||||
|
||||
while i < endIndex {
|
||||
// Calculate the next value of w.
|
||||
w *= nextW(k: k, using: &rng)
|
||||
|
||||
|
||||
// Find index of the next element to swap into the reservoir.
|
||||
let offset = nextOffset(w: w, using: &rng)
|
||||
i = index(i, offsetBy: offset, limitedBy: endIndex) ?? endIndex
|
||||
|
||||
|
||||
if i < endIndex {
|
||||
// Swap selected element with a randomly chosen one in the reservoir.
|
||||
let j = Int.random(in: 0..<result.count, using: &rng)
|
||||
@@ -143,12 +142,12 @@ extension Collection {
|
||||
formIndex(after: &i)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// FIXME: necessary?
|
||||
result.shuffle(using: &rng)
|
||||
return result
|
||||
}
|
||||
|
||||
|
||||
/// Randomly selects the specified number of elements from this collection.
|
||||
///
|
||||
/// This method is equivalent to calling `randomSample(k:using:)`, passing in
|
||||
@@ -186,11 +185,11 @@ extension Sequence {
|
||||
count k: Int, using rng: inout G
|
||||
) -> [Element] {
|
||||
guard k > 0 else { return [] }
|
||||
|
||||
|
||||
var w = 1.0
|
||||
var result: [Element] = []
|
||||
result.reserveCapacity(k)
|
||||
|
||||
|
||||
// Fill the reservoir with the first `k` elements.
|
||||
var iterator = makeIterator()
|
||||
while result.count < k, let el = iterator.next() {
|
||||
@@ -200,26 +199,26 @@ extension Sequence {
|
||||
while true {
|
||||
// Calculate the next value of w.
|
||||
w *= nextW(k: k, using: &rng)
|
||||
|
||||
|
||||
// Find the offset of the next element to swap into the reservoir.
|
||||
var offset = nextOffset(w: w, using: &rng)
|
||||
|
||||
|
||||
// Skip over `offset` elements to find the selected element.
|
||||
while offset > 0, let _ = iterator.next() {
|
||||
offset -= 1
|
||||
}
|
||||
guard let nextElement = iterator.next() else { break }
|
||||
|
||||
|
||||
// Swap selected element with a randomly chosen one in the reservoir.
|
||||
let j = Int.random(in: 0..<result.count, using: &rng)
|
||||
result[j] = nextElement
|
||||
}
|
||||
|
||||
|
||||
// FIXME: necessary?
|
||||
result.shuffle(using: &rng)
|
||||
return result
|
||||
}
|
||||
|
||||
|
||||
/// Randomly selects the specified number of elements from this sequence.
|
||||
///
|
||||
/// This method is equivalent to calling `randomSample(k:using:)`, passing in
|
||||
|
||||
@@ -234,9 +234,10 @@ extension ExclusiveReductions: Sequence {
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(iterator: base.makeIterator(),
|
||||
current: initial,
|
||||
transform: transform)
|
||||
Iterator(
|
||||
iterator: base.makeIterator(),
|
||||
current: initial,
|
||||
transform: transform)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -317,10 +318,10 @@ extension ExclusiveReductions: Collection where Base: Collection {
|
||||
}
|
||||
|
||||
extension ExclusiveReductions: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension ExclusiveReductions: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
// MARK: - Inclusive Reductions
|
||||
|
||||
@@ -453,8 +454,9 @@ extension InclusiveReductions: Sequence {
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(iterator: base.makeIterator(),
|
||||
transform: transform)
|
||||
Iterator(
|
||||
iterator: base.makeIterator(),
|
||||
transform: transform)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -537,10 +539,10 @@ extension InclusiveReductions: Collection where Base: Collection {
|
||||
}
|
||||
|
||||
extension InclusiveReductions: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension InclusiveReductions: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
// MARK: - ReductionsIndexRepresentation
|
||||
|
||||
|
||||
@@ -43,7 +43,7 @@ extension MutableCollection where Self: BidirectionalCollection {
|
||||
}
|
||||
return (lower, upper)
|
||||
}
|
||||
|
||||
|
||||
/// Reverses the elements within the given subrange.
|
||||
///
|
||||
/// This example reverses the numbers within the subrange at the start of the
|
||||
@@ -100,15 +100,14 @@ extension MutableCollection {
|
||||
) -> (Index, Index) {
|
||||
assert(!lhs.isEmpty)
|
||||
assert(!rhs.isEmpty)
|
||||
|
||||
|
||||
var p = lhs.lowerBound
|
||||
var q = rhs.lowerBound
|
||||
repeat {
|
||||
swapAt(p, q)
|
||||
formIndex(after: &p)
|
||||
formIndex(after: &q)
|
||||
}
|
||||
while p != lhs.upperBound && q != rhs.upperBound
|
||||
} while p != lhs.upperBound && q != rhs.upperBound
|
||||
return (p, q)
|
||||
}
|
||||
|
||||
@@ -139,13 +138,14 @@ extension MutableCollection {
|
||||
subrange: Range<Index>,
|
||||
toStartAt newStart: Index
|
||||
) -> Index {
|
||||
var m = newStart, s = subrange.lowerBound
|
||||
var m = newStart
|
||||
var s = subrange.lowerBound
|
||||
let e = subrange.upperBound
|
||||
|
||||
|
||||
// Handle the trivial cases
|
||||
if s == m { return e }
|
||||
if m == e { return s }
|
||||
|
||||
|
||||
// We have two regions of possibly-unequal length that need to be
|
||||
// exchanged. The return value of this method is going to be the
|
||||
// position following that of the element that is currently last
|
||||
@@ -155,7 +155,7 @@ extension MutableCollection {
|
||||
// ^ ^ ^ ^ ^ ^
|
||||
// s m e s m e
|
||||
//
|
||||
var ret = e // start with a known incorrect result.
|
||||
var ret = e // start with a known incorrect result.
|
||||
while true {
|
||||
// Exchange the leading elements of each region (up to the
|
||||
// length of the shorter region).
|
||||
@@ -167,7 +167,7 @@ extension MutableCollection {
|
||||
// s s1 m m1/e s s1/m m1 e
|
||||
//
|
||||
let (s1, m1) = _swapNonemptySubrangePrefixes(s..<m, m..<e)
|
||||
|
||||
|
||||
if m1 == e {
|
||||
// Left-hand case: we have moved element j into position. if
|
||||
// we haven't already, we can capture the return value which
|
||||
@@ -177,11 +177,11 @@ extension MutableCollection {
|
||||
// comparison once the return value is known. I'm not sure
|
||||
// it's a worthwhile optimization, though.
|
||||
if ret == e { ret = s1 }
|
||||
|
||||
|
||||
// If both regions were the same size, we're done.
|
||||
if s1 == m { break }
|
||||
}
|
||||
|
||||
|
||||
// Now we have a smaller problem that is also a rotation, so we
|
||||
// can adjust our bounds and repeat.
|
||||
//
|
||||
@@ -191,10 +191,10 @@ extension MutableCollection {
|
||||
s = s1
|
||||
if s == m { m = m1 }
|
||||
}
|
||||
|
||||
|
||||
return ret
|
||||
}
|
||||
|
||||
|
||||
/// Rotates the elements of this collection so that the element
|
||||
/// at the specified index becomes the start of the collection.
|
||||
///
|
||||
@@ -287,11 +287,11 @@ extension MutableCollection {
|
||||
@discardableResult
|
||||
public mutating func rotate(
|
||||
subrange: Range<Index>,
|
||||
at newStart: Index) -> Index
|
||||
{
|
||||
at newStart: Index
|
||||
) -> Index {
|
||||
rotate(subrange: subrange, toStartAt: newStart)
|
||||
}
|
||||
|
||||
|
||||
@available(*, deprecated, renamed: "rotate(toStartAt:)")
|
||||
@discardableResult
|
||||
public mutating func rotate(at newStart: Index) -> Index {
|
||||
|
||||
@@ -54,13 +54,13 @@ extension Collection {
|
||||
|
||||
/// A wrapper that strides over a base sequence.
|
||||
public struct StrideSequence<Base: Sequence>: Sequence {
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let stride: Int
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, stride: Int) {
|
||||
precondition(stride > 0, "striding must be greater than zero")
|
||||
@@ -70,24 +70,24 @@ public struct StrideSequence<Base: Sequence>: Sequence {
|
||||
}
|
||||
|
||||
extension StrideSequence {
|
||||
|
||||
|
||||
/// An iterator over a `Stride` sequence.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var iterator: Base.Iterator
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let stride: Int
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var striding: Bool = false
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(iterator: Base.Iterator, stride: Int) {
|
||||
self.iterator = iterator
|
||||
self.stride = stride
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Base.Element? {
|
||||
guard striding else {
|
||||
@@ -100,7 +100,7 @@ extension StrideSequence {
|
||||
return iterator.next()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(iterator: base.makeIterator(), stride: stride)
|
||||
@@ -118,10 +118,10 @@ extension StrideSequence {
|
||||
public struct StrideCollection<Base: Collection> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let stride: Int
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, stride: Int) {
|
||||
precondition(stride > 0, "striding must be greater than zero")
|
||||
@@ -138,44 +138,44 @@ extension StrideCollection {
|
||||
}
|
||||
|
||||
extension StrideCollection: Collection {
|
||||
|
||||
|
||||
/// A position in a `Stride` collection.
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal let base: Base.Index
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal init(_ base: Base.Index) {
|
||||
self.base = base
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Index, rhs: Index) -> Bool {
|
||||
lhs.base < rhs.base
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(base.startIndex)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(base.endIndex)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public subscript(i: Index) -> Base.Element {
|
||||
base[i.base]
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i.base < base.endIndex, "Advancing past end index")
|
||||
return index(i, offsetBy: 1)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ i: Index,
|
||||
@@ -184,12 +184,12 @@ extension StrideCollection: Collection {
|
||||
) -> Index? {
|
||||
guard n != 0 else { return i }
|
||||
guard limit != i else { return nil }
|
||||
|
||||
|
||||
return n > 0
|
||||
? offsetForward(i, offsetBy: n, limitedBy: limit)
|
||||
: offsetBackward(i, offsetBy: -n, limitedBy: limit)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(
|
||||
_ i: Index,
|
||||
@@ -219,34 +219,35 @@ extension StrideCollection: Collection {
|
||||
: nil
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ i: Index,
|
||||
offsetBy n: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
let distance = i == endIndex
|
||||
let distance =
|
||||
i == endIndex
|
||||
? -((base.count - 1) % stride + 1) + (n - 1) * -stride
|
||||
: n * -stride
|
||||
return base.index(
|
||||
i.base,
|
||||
offsetBy: distance,
|
||||
limitedBy: limit.base
|
||||
i.base,
|
||||
offsetBy: distance,
|
||||
limitedBy: limit.base
|
||||
).map(Index.init)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var count: Int {
|
||||
base.isEmpty ? 0 : (base.count - 1) / stride + 1
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
let distance = base.distance(from: start.base, to: end.base)
|
||||
return distance / stride + (distance % stride).signum()
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
precondition(distance <= 0 || i.base < base.endIndex, "Advancing past end index")
|
||||
@@ -259,8 +260,8 @@ extension StrideCollection: Collection {
|
||||
}
|
||||
|
||||
extension StrideCollection: BidirectionalCollection
|
||||
where Base: RandomAccessCollection {
|
||||
|
||||
where Base: RandomAccessCollection {
|
||||
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i.base > base.startIndex, "Incrementing past start index")
|
||||
|
||||
@@ -14,11 +14,11 @@ public struct Uniqued<Base: Sequence, Subject: Hashable> {
|
||||
/// The base collection.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
/// The projection function.
|
||||
@usableFromInline
|
||||
internal let projection: (Base.Element) -> Subject
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal init(base: Base, projection: @escaping (Base.Element) -> Subject) {
|
||||
self.base = base
|
||||
@@ -31,13 +31,13 @@ extension Uniqued: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var base: Base.Iterator
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let projection: (Base.Element) -> Subject
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var seen: Set<Subject> = []
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal init(
|
||||
base: Base.Iterator,
|
||||
@@ -46,7 +46,7 @@ extension Uniqued: Sequence {
|
||||
self.base = base
|
||||
self.projection = projection
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Base.Element? {
|
||||
while let element = base.next() {
|
||||
@@ -57,7 +57,7 @@ extension Uniqued: Sequence {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(base: base.makeIterator(), projection: projection)
|
||||
|
||||
@@ -49,10 +49,10 @@ extension Collection {
|
||||
public struct Windows<Base: Collection> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let size: Int
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var firstUpperBound: Base.Index?
|
||||
|
||||
@@ -71,27 +71,27 @@ extension Windows: Collection {
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal var lowerBound: Base.Index
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var upperBound: Base.Index
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(lowerBound: Base.Index, upperBound: Base.Index) {
|
||||
self.lowerBound = lowerBound
|
||||
self.upperBound = upperBound
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Index, rhs: Index) -> Bool {
|
||||
lhs.lowerBound == rhs.lowerBound
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Index, rhs: Index) -> Bool {
|
||||
lhs.lowerBound < rhs.lowerBound
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
if let upperBound = firstUpperBound {
|
||||
@@ -100,12 +100,12 @@ extension Windows: Collection {
|
||||
return endIndex
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(lowerBound: base.endIndex, upperBound: base.endIndex)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public subscript(index: Index) -> Base.SubSequence {
|
||||
precondition(
|
||||
@@ -113,7 +113,7 @@ extension Windows: Collection {
|
||||
"Windows index is out of range")
|
||||
return base[index.lowerBound..<index.upperBound]
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(after index: Index) -> Index {
|
||||
precondition(index < endIndex, "Advancing past end index")
|
||||
@@ -123,16 +123,16 @@ extension Windows: Collection {
|
||||
upperBound: base.index(after: index.upperBound)
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
guard distance != 0 else { return i }
|
||||
|
||||
|
||||
return distance > 0
|
||||
? offsetForward(i, by: distance)
|
||||
: offsetBackward(i, by: -distance)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ i: Index,
|
||||
@@ -141,7 +141,7 @@ extension Windows: Collection {
|
||||
) -> Index? {
|
||||
guard distance != 0 else { return i }
|
||||
guard limit != i else { return nil }
|
||||
|
||||
|
||||
if distance > 0 {
|
||||
return limit > i
|
||||
? offsetForward(i, by: distance, limitedBy: limit)
|
||||
@@ -152,28 +152,28 @@ extension Windows: Collection {
|
||||
: offsetBackward(i, by: -distance)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetForward(i, by: distance, limitedBy: endIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetBackward(i, by: distance, limitedBy: startIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
assert(limit > i)
|
||||
|
||||
|
||||
// `endIndex` and the index before it both have `base.endIndex` as their
|
||||
// upper bound, so we first advance to the base index _before_ the upper
|
||||
// bound of the output, in order to avoid advancing past the end of `base`
|
||||
@@ -184,31 +184,31 @@ extension Windows: Collection {
|
||||
// input: [x|x x x x x|x x x x] [x x|x x x x x|x x x]
|
||||
// |> > >|>| or |> > >|
|
||||
// output: [x x x x x|x x x x x] [x x x x x x x x x x] (`endIndex`)
|
||||
|
||||
|
||||
if distance >= size {
|
||||
// Avoid traversing `self[i.lowerBound..<i.upperBound]` when the lower
|
||||
// bound of the output is greater than or equal to the upper bound of the
|
||||
// input.
|
||||
|
||||
|
||||
// input: [x|x x x x|x x x x x x x]
|
||||
// |> >|> > >|>|
|
||||
// output: [x x x x x x x|x x x x|x]
|
||||
|
||||
|
||||
guard limit.lowerBound >= i.upperBound,
|
||||
let lowerBound = base.index(
|
||||
i.upperBound,
|
||||
offsetBy: distance - size,
|
||||
limitedBy: limit.lowerBound),
|
||||
let indexBeforeUpperBound = base.index(
|
||||
lowerBound,
|
||||
offsetBy: size - 1,
|
||||
limitedBy: limit.upperBound)
|
||||
let lowerBound = base.index(
|
||||
i.upperBound,
|
||||
offsetBy: distance - size,
|
||||
limitedBy: limit.lowerBound),
|
||||
let indexBeforeUpperBound = base.index(
|
||||
lowerBound,
|
||||
offsetBy: size - 1,
|
||||
limitedBy: limit.upperBound)
|
||||
else { return nil }
|
||||
|
||||
|
||||
// If `indexBeforeUpperBound` equals `base.endIndex`, we're advancing to
|
||||
// `endIndex`.
|
||||
guard indexBeforeUpperBound != base.endIndex else { return endIndex }
|
||||
|
||||
|
||||
return Index(
|
||||
lowerBound: lowerBound,
|
||||
upperBound: base.index(after: indexBeforeUpperBound))
|
||||
@@ -216,35 +216,36 @@ extension Windows: Collection {
|
||||
// input: [x|x x x x x x|x x x x x]
|
||||
// |> > > >| |> > >|>|
|
||||
// output: [x x x x x|x x x x x x|x]
|
||||
|
||||
guard let indexBeforeUpperBound = base.index(
|
||||
i.upperBound,
|
||||
offsetBy: distance - 1,
|
||||
limitedBy: limit.upperBound)
|
||||
|
||||
guard
|
||||
let indexBeforeUpperBound = base.index(
|
||||
i.upperBound,
|
||||
offsetBy: distance - 1,
|
||||
limitedBy: limit.upperBound)
|
||||
else { return nil }
|
||||
|
||||
|
||||
// If `indexBeforeUpperBound` equals the limit, the upper bound itself
|
||||
// exceeds it.
|
||||
guard indexBeforeUpperBound != limit.upperBound || limit == endIndex
|
||||
else { return nil }
|
||||
|
||||
else { return nil }
|
||||
|
||||
// If `indexBeforeUpperBound` equals `base.endIndex`, we're advancing to
|
||||
// `endIndex`.
|
||||
guard indexBeforeUpperBound != base.endIndex else { return endIndex }
|
||||
|
||||
|
||||
return Index(
|
||||
lowerBound: base.index(i.lowerBound, offsetBy: distance),
|
||||
upperBound: base.index(after: indexBeforeUpperBound))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
assert(limit < i)
|
||||
|
||||
|
||||
if i == endIndex {
|
||||
// Advance `base.endIndex` by `distance - 1`, because the index before
|
||||
// `endIndex` also has `base.endIndex` as its upper bound.
|
||||
@@ -254,13 +255,14 @@ extension Windows: Collection {
|
||||
// input: [x x x x x x x x x x] (`endIndex`)
|
||||
// |< < < < <|< < <|
|
||||
// output: [x x|x x x x x|x x x]
|
||||
|
||||
guard let upperBound = base.index(
|
||||
base.endIndex,
|
||||
offsetBy: -(distance - 1),
|
||||
limitedBy: limit.upperBound)
|
||||
|
||||
guard
|
||||
let upperBound = base.index(
|
||||
base.endIndex,
|
||||
offsetBy: -(distance - 1),
|
||||
limitedBy: limit.upperBound)
|
||||
else { return nil }
|
||||
|
||||
|
||||
return Index(
|
||||
lowerBound: base.index(upperBound, offsetBy: -size),
|
||||
upperBound: upperBound)
|
||||
@@ -272,14 +274,14 @@ extension Windows: Collection {
|
||||
// input: [x x x x x x x|x x x x|x]
|
||||
// |< < < <|< <|
|
||||
// output: [x|x x x x|x x x x x x x]
|
||||
|
||||
|
||||
guard limit.upperBound <= i.lowerBound,
|
||||
let upperBound = base.index(
|
||||
i.lowerBound,
|
||||
offsetBy: -(distance - size),
|
||||
limitedBy: limit.upperBound)
|
||||
let upperBound = base.index(
|
||||
i.lowerBound,
|
||||
offsetBy: -(distance - size),
|
||||
limitedBy: limit.upperBound)
|
||||
else { return nil }
|
||||
|
||||
|
||||
return Index(
|
||||
lowerBound: base.index(upperBound, offsetBy: -size),
|
||||
upperBound: upperBound)
|
||||
@@ -287,19 +289,20 @@ extension Windows: Collection {
|
||||
// input: [x x x x x|x x x x x x|x]
|
||||
// |< < < <| |< < < <|
|
||||
// output: [x|x x x x x x|x x x x x]
|
||||
|
||||
guard let lowerBound = base.index(
|
||||
i.lowerBound,
|
||||
offsetBy: -distance,
|
||||
limitedBy: limit.lowerBound)
|
||||
|
||||
guard
|
||||
let lowerBound = base.index(
|
||||
i.lowerBound,
|
||||
offsetBy: -distance,
|
||||
limitedBy: limit.lowerBound)
|
||||
else { return nil }
|
||||
|
||||
|
||||
return Index(
|
||||
lowerBound: lowerBound,
|
||||
upperBound: base.index(i.lowerBound, offsetBy: -distance))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
guard start <= end else { return -distance(from: end, to: start) }
|
||||
@@ -317,13 +320,13 @@ extension Windows: Collection {
|
||||
// start: [x|x x x x|x x x x x x x]
|
||||
// |- - - -|> >|
|
||||
// end: [x x x x x x x|x x x x|x]
|
||||
|
||||
|
||||
return size + base[start.upperBound..<end.lowerBound].count
|
||||
} else {
|
||||
// start: [x|x x x x x x|x x x x x]
|
||||
// |> > > >|
|
||||
// end: [x x x x x|x x x x x x|x]
|
||||
|
||||
|
||||
return base[start.lowerBound..<end.lowerBound].count
|
||||
}
|
||||
}
|
||||
|
||||
@@ -11,9 +11,9 @@
|
||||
|
||||
#error("""
|
||||
|
||||
-----------------------------------------------------
|
||||
-----------------------------------------------------
|
||||
|
||||
Please test with `swift test --enable-test-discovery`
|
||||
Please test with `swift test --enable-test-discovery`
|
||||
|
||||
-----------------------------------------------------
|
||||
""")
|
||||
-----------------------------------------------------
|
||||
""")
|
||||
@@ -10,6 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
|
||||
@testable import Algorithms
|
||||
|
||||
final class ChainTests: XCTestCase {
|
||||
@@ -17,24 +18,24 @@ final class ChainTests: XCTestCase {
|
||||
let run = chain((1...).prefix(10), 20...)
|
||||
XCTAssertEqualSequences(run.prefix(20), Array(1...10) + (20..<30))
|
||||
}
|
||||
|
||||
|
||||
func testChainForwardCollection() {
|
||||
let s1 = Set(0...10)
|
||||
let s2 = Set(20...30)
|
||||
let c = chain(s1, s2)
|
||||
XCTAssertEqualSequences(c, Array(s1) + Array(s2))
|
||||
}
|
||||
|
||||
|
||||
func testChainBidirectionalCollection() {
|
||||
let s1 = "ABCDEFGHIJ"
|
||||
let s2 = "klmnopqrstuv"
|
||||
let c = chain(s1, s2)
|
||||
|
||||
|
||||
XCTAssertEqualSequences(c, "ABCDEFGHIJklmnopqrstuv")
|
||||
XCTAssertEqualSequences(c.reversed(), "ABCDEFGHIJklmnopqrstuv".reversed())
|
||||
XCTAssertEqualSequences(chain(s1.reversed(), s2), "JIHGFEDCBAklmnopqrstuv")
|
||||
}
|
||||
|
||||
|
||||
func testChainIndexTraversals() {
|
||||
validateIndexTraversals(
|
||||
chain("abcd", "XYZ"),
|
||||
@@ -47,21 +48,21 @@ final class ChainTests: XCTestCase {
|
||||
+ [.init(second: chain.base2.endIndex)]
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
func testChainIndexOffsetAcrossBoundary() {
|
||||
let c = chain("abc", "XYZ")
|
||||
|
||||
|
||||
do {
|
||||
let i = c.index(c.startIndex, offsetBy: 3, limitedBy: c.startIndex)
|
||||
XCTAssertNil(i)
|
||||
}
|
||||
|
||||
|
||||
do {
|
||||
let i = c.index(c.startIndex, offsetBy: 4)
|
||||
let j = c.index(i, offsetBy: -2)
|
||||
XCTAssertEqual(c[j], "c")
|
||||
}
|
||||
|
||||
|
||||
do {
|
||||
let i = c.index(c.startIndex, offsetBy: 3)
|
||||
let j = c.index(i, offsetBy: -1, limitedBy: i)
|
||||
|
||||
@@ -9,23 +9,22 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class ChunkedTests: XCTestCase {
|
||||
let fruits = [
|
||||
"Apple", "Apricot", "Avocado", "Banana",
|
||||
"Bilberry", "Blackberry", "Blackcurrant", "Blueberry",
|
||||
"Currant", "Cherry", "Cherimoya", "Clementine",
|
||||
"Date", "Damson", "Dragonfruit", "Durian",
|
||||
"Eggplant", "Elderberry", "Feijoa",
|
||||
"Grape", "Grapefruit", "Guava",
|
||||
"Apple", "Apricot", "Avocado", "Banana",
|
||||
"Bilberry", "Blackberry", "Blackcurrant", "Blueberry",
|
||||
"Currant", "Cherry", "Cherimoya", "Clementine",
|
||||
"Date", "Damson", "Dragonfruit", "Durian",
|
||||
"Eggplant", "Elderberry", "Feijoa",
|
||||
"Grape", "Grapefruit", "Guava",
|
||||
]
|
||||
|
||||
func validateFruitChunks<C: BidirectionalCollection>(_ fruitChunks: C)
|
||||
where C.Element == ArraySlice<String>
|
||||
{
|
||||
let expectedChunks: Array<ArraySlice<String>> = [
|
||||
where C.Element == ArraySlice<String> {
|
||||
let expectedChunks: [ArraySlice<String>] = [
|
||||
fruits[0..<3],
|
||||
fruits[3..<8],
|
||||
fruits[8..<12],
|
||||
@@ -35,21 +34,21 @@ final class ChunkedTests: XCTestCase {
|
||||
fruits[19..<22],
|
||||
]
|
||||
XCTAssertEqualSequences(expectedChunks, fruitChunks, by: ==)
|
||||
|
||||
|
||||
XCTAssertEqual(fruits[19..<22], fruitChunks.last)
|
||||
|
||||
|
||||
XCTAssertEqual("Currant", fruitChunks.first(where: { $0.count == 4 })?.first)
|
||||
XCTAssertEqual("Date", fruitChunks.last(where: { $0.count == 4 })?.first)
|
||||
XCTAssertNil(fruitChunks.first(where: { $0.count == 0 }))
|
||||
XCTAssertNil(fruitChunks.last(where: { $0.count == 0 }))
|
||||
}
|
||||
|
||||
|
||||
func testSimple() {
|
||||
// Example
|
||||
let names = ["David", "Kyle", "Karoy", "Nate"]
|
||||
let chunks = names.chunked(on: { $0.first })
|
||||
XCTAssertEqualSequences([["David"], ["Kyle", "Karoy"], ["Nate"]], chunks)
|
||||
|
||||
|
||||
// Empty sequence
|
||||
XCTAssertEqual(0, names.prefix(0).chunked(on: { $0.first }).count)
|
||||
|
||||
@@ -57,27 +56,26 @@ final class ChunkedTests: XCTestCase {
|
||||
let namesStartingWithD = ["David", "Don", "Darren"]
|
||||
XCTAssertEqual(1, namesStartingWithD.chunked(on: { $0.first }).count)
|
||||
}
|
||||
|
||||
|
||||
func testChunkedOn() {
|
||||
validateFruitChunks(fruits.chunked(on: { $0.first }))
|
||||
|
||||
|
||||
let lazyChunks = fruits.lazy.chunked(on: { $0.first })
|
||||
validateFruitChunks(lazyChunks)
|
||||
}
|
||||
|
||||
func testChunkedBy() {
|
||||
validateFruitChunks(fruits.chunked(by: { $0.first == $1.first }))
|
||||
|
||||
|
||||
let lazyChunks = fruits.lazy.chunked(by: { $0.first == $1.first })
|
||||
validateFruitChunks(lazyChunks)
|
||||
}
|
||||
|
||||
|
||||
func testChunkedLazy() {
|
||||
XCTAssertLazySequence(fruits.lazy.chunked(by: { $0.first == $1.first }))
|
||||
XCTAssertLazySequence(fruits.lazy.chunked(on: { $0.first }))
|
||||
}
|
||||
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Tests for `chunks(ofCount:)`
|
||||
//===----------------------------------------------------------------------===//
|
||||
@@ -86,37 +84,47 @@ final class ChunkedTests: XCTestCase {
|
||||
XCTAssertEqualSequences([Int]().chunks(ofCount: 5), [])
|
||||
|
||||
let collection1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
XCTAssertEqualSequences(collection1.chunks(ofCount: 1),
|
||||
[[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])
|
||||
XCTAssertEqualSequences(collection1.chunks(ofCount: 3),
|
||||
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]])
|
||||
XCTAssertEqualSequences(collection1.chunks(ofCount: 5),
|
||||
[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
|
||||
XCTAssertEqualSequences(collection1.chunks(ofCount: 11),
|
||||
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
collection1.chunks(ofCount: 1),
|
||||
[[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])
|
||||
XCTAssertEqualSequences(
|
||||
collection1.chunks(ofCount: 3),
|
||||
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]])
|
||||
XCTAssertEqualSequences(
|
||||
collection1.chunks(ofCount: 5),
|
||||
[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
|
||||
XCTAssertEqualSequences(
|
||||
collection1.chunks(ofCount: 11),
|
||||
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])
|
||||
|
||||
let collection2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
|
||||
XCTAssertEqualSequences(collection2.chunks(ofCount: 3),
|
||||
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11]])
|
||||
XCTAssertEqualSequences(
|
||||
collection2.chunks(ofCount: 3),
|
||||
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11]])
|
||||
}
|
||||
|
||||
|
||||
func testChunksOfCountBidirectional() {
|
||||
let collection1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
|
||||
XCTAssertEqualSequences(collection1.chunks(ofCount: 1).reversed(),
|
||||
[[10], [9], [8], [7], [6], [5], [4], [3], [2], [1]])
|
||||
XCTAssertEqualSequences(collection1.chunks(ofCount: 3).reversed(),
|
||||
[[10], [7, 8, 9], [4, 5, 6], [1, 2, 3]])
|
||||
XCTAssertEqualSequences(collection1.chunks(ofCount: 5).reversed(),
|
||||
[[6, 7, 8, 9, 10], [1, 2, 3, 4, 5]])
|
||||
XCTAssertEqualSequences(collection1.chunks(ofCount: 11).reversed(),
|
||||
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
collection1.chunks(ofCount: 1).reversed(),
|
||||
[[10], [9], [8], [7], [6], [5], [4], [3], [2], [1]])
|
||||
XCTAssertEqualSequences(
|
||||
collection1.chunks(ofCount: 3).reversed(),
|
||||
[[10], [7, 8, 9], [4, 5, 6], [1, 2, 3]])
|
||||
XCTAssertEqualSequences(
|
||||
collection1.chunks(ofCount: 5).reversed(),
|
||||
[[6, 7, 8, 9, 10], [1, 2, 3, 4, 5]])
|
||||
XCTAssertEqualSequences(
|
||||
collection1.chunks(ofCount: 11).reversed(),
|
||||
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])
|
||||
|
||||
let collection2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
|
||||
XCTAssertEqualSequences(collection2.chunks(ofCount: 3).reversed(),
|
||||
[[10, 11], [7, 8, 9], [4, 5, 6], [1, 2, 3]])
|
||||
XCTAssertEqualSequences(
|
||||
collection2.chunks(ofCount: 3).reversed(),
|
||||
[[10, 11], [7, 8, 9], [4, 5, 6], [1, 2, 3]])
|
||||
}
|
||||
|
||||
|
||||
func testChunksOfCountCount() {
|
||||
XCTAssertEqual([Int]().chunks(ofCount: 1).count, 0)
|
||||
XCTAssertEqual([Int]().chunks(ofCount: 5).count, 0)
|
||||
@@ -126,22 +134,22 @@ final class ChunkedTests: XCTestCase {
|
||||
XCTAssertEqual(collection1.chunks(ofCount: 3).count, 4)
|
||||
XCTAssertEqual(collection1.chunks(ofCount: 5).count, 2)
|
||||
XCTAssertEqual(collection1.chunks(ofCount: 11).count, 1)
|
||||
|
||||
|
||||
let collection2 = (1...50).map { $0 }
|
||||
XCTAssertEqual(collection2.chunks(ofCount: 9).count, 6)
|
||||
}
|
||||
|
||||
func testEmptyChunksOfCountTraversal() {
|
||||
let emptyChunks = [Int]().chunks(ofCount: 1)
|
||||
|
||||
|
||||
validateIndexTraversals(emptyChunks)
|
||||
}
|
||||
|
||||
|
||||
func testChunksOfCountTraversal() {
|
||||
for i in 1..<10 {
|
||||
let collection = (1...50).map { $0 }
|
||||
let chunks = collection.chunks(ofCount: i)
|
||||
|
||||
|
||||
validateIndexTraversals(chunks)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,113 +9,131 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class CombinationsTests: XCTestCase {
|
||||
func testCount() {
|
||||
let c = "ABCD"
|
||||
|
||||
|
||||
let c0 = c.combinations(ofCount: 0).count
|
||||
XCTAssertEqual(c0, 1)
|
||||
|
||||
|
||||
let c1 = c.combinations(ofCount: 1).count
|
||||
XCTAssertEqual(c1, 4)
|
||||
|
||||
|
||||
let c2 = c.combinations(ofCount: 2).count
|
||||
XCTAssertEqual(c2, 6)
|
||||
|
||||
|
||||
let c3 = c.combinations(ofCount: 3).count
|
||||
XCTAssertEqual(c3, 4)
|
||||
|
||||
|
||||
let c4 = c.combinations(ofCount: 4).count
|
||||
XCTAssertEqual(c4, 1)
|
||||
|
||||
|
||||
let c5 = c.combinations(ofCount: 0...0).count
|
||||
XCTAssertEqual(c5, 1)
|
||||
|
||||
|
||||
let c6 = c.combinations(ofCount: 1...1).count
|
||||
XCTAssertEqual(c6, 4)
|
||||
|
||||
|
||||
let c7 = c.combinations(ofCount: 1...2).count
|
||||
XCTAssertEqual(c7, 10)
|
||||
|
||||
|
||||
let c8 = c.combinations(ofCount: 1...3).count
|
||||
XCTAssertEqual(c8, 14)
|
||||
|
||||
|
||||
let c9 = c.combinations(ofCount: 2...4).count
|
||||
XCTAssertEqual(c9, 11)
|
||||
|
||||
|
||||
// `k` greater than element count results in same number of combinations
|
||||
let c10 = c.combinations(ofCount: 3...10).count
|
||||
XCTAssertEqual(c10, 5)
|
||||
|
||||
|
||||
// `k` greater than element count results in same number of combinations
|
||||
let c11 = c.combinations(ofCount: 4...10).count
|
||||
XCTAssertEqual(c11, 1)
|
||||
|
||||
|
||||
// `k` entirely greater than element count results in no combinations
|
||||
let c12 = c.combinations(ofCount: 5...10).count
|
||||
XCTAssertEqual(c12, 0)
|
||||
|
||||
|
||||
let c13 = c.combinations(ofCount: 0...).count
|
||||
XCTAssertEqual(c13, 16)
|
||||
|
||||
|
||||
let c14 = c.combinations(ofCount: ...3).count
|
||||
XCTAssertEqual(c14, 15)
|
||||
|
||||
|
||||
let c15 = c.combinations(ofCount: 0...).count
|
||||
XCTAssertEqual(c15, 16)
|
||||
}
|
||||
|
||||
|
||||
func testCombinations() {
|
||||
let c = "ABCD"
|
||||
|
||||
|
||||
let c1 = c.combinations(ofCount: 1)
|
||||
XCTAssertEqual(["A", "B", "C", "D"], c1.map { String($0) })
|
||||
|
||||
|
||||
let c2 = c.combinations(ofCount: 2)
|
||||
XCTAssertEqual(["AB", "AC", "AD", "BC", "BD", "CD"], c2.map { String($0) })
|
||||
|
||||
|
||||
let c3 = c.combinations(ofCount: 3)
|
||||
XCTAssertEqual(["ABC", "ABD", "ACD", "BCD"], c3.map { String($0) })
|
||||
|
||||
|
||||
let c4 = c.combinations(ofCount: 4)
|
||||
XCTAssertEqual(["ABCD"], c4.map { String($0) })
|
||||
|
||||
|
||||
let c5 = c.combinations(ofCount: 2...4)
|
||||
XCTAssertEqual(["AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c5.map { String($0) })
|
||||
|
||||
XCTAssertEqual(
|
||||
["AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"],
|
||||
c5.map { String($0) })
|
||||
|
||||
let c6 = c.combinations(ofCount: 0...4)
|
||||
XCTAssertEqual(["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c6.map { String($0) })
|
||||
|
||||
XCTAssertEqual(
|
||||
[
|
||||
"", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD",
|
||||
"ABCD",
|
||||
], c6.map { String($0) })
|
||||
|
||||
let c7 = c.combinations(ofCount: 0...)
|
||||
XCTAssertEqual(["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c7.map { String($0) })
|
||||
|
||||
XCTAssertEqual(
|
||||
[
|
||||
"", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD",
|
||||
"ABCD",
|
||||
], c7.map { String($0) })
|
||||
|
||||
let c8 = c.combinations(ofCount: ...4)
|
||||
XCTAssertEqual(["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c8.map { String($0) })
|
||||
|
||||
XCTAssertEqual(
|
||||
[
|
||||
"", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD",
|
||||
"ABCD",
|
||||
], c8.map { String($0) })
|
||||
|
||||
let c9 = c.combinations(ofCount: ...3)
|
||||
XCTAssertEqual(["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD"], c9.map { String($0) })
|
||||
|
||||
XCTAssertEqual(
|
||||
["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD"],
|
||||
c9.map { String($0) })
|
||||
|
||||
let c10 = c.combinations(ofCount: 1...)
|
||||
XCTAssertEqual(["A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c10.map { String($0) })
|
||||
XCTAssertEqual(
|
||||
["A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"],
|
||||
c10.map { String($0) })
|
||||
}
|
||||
|
||||
|
||||
func testEmpty() {
|
||||
// `k == 0` results in one zero-length combination
|
||||
XCTAssertEqualSequences([[]], "".combinations(ofCount: 0))
|
||||
XCTAssertEqualSequences([[]], "".combinations(ofCount: 0...0))
|
||||
XCTAssertEqualSequences([[]], "ABCD".combinations(ofCount: 0))
|
||||
XCTAssertEqualSequences([[]], "ABCD".combinations(ofCount: 0...0))
|
||||
|
||||
|
||||
// `k` greater than element count results in zero combinations
|
||||
XCTAssertEqualSequences([], "".combinations(ofCount: 5))
|
||||
XCTAssertEqualSequences([], "".combinations(ofCount: 5...10))
|
||||
XCTAssertEqualSequences([], "ABCD".combinations(ofCount: 5))
|
||||
XCTAssertEqualSequences([], "ABCD".combinations(ofCount: 5...10))
|
||||
}
|
||||
|
||||
|
||||
func testCombinationsLazy() {
|
||||
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1))
|
||||
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1...3))
|
||||
|
||||
@@ -9,16 +9,16 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class CompactedTests: XCTestCase {
|
||||
|
||||
let tests: [[Int?]] =
|
||||
[nil, nil, nil, 0, 1, 2]
|
||||
.uniquePermutations(ofCount: 0...)
|
||||
.map(Array.init)
|
||||
|
||||
.uniquePermutations(ofCount: 0...)
|
||||
.map(Array.init)
|
||||
|
||||
func testCompactedCompacted() {
|
||||
for collection in self.tests {
|
||||
let seq = AnySequence(collection)
|
||||
@@ -31,11 +31,12 @@ final class CompactedTests: XCTestCase {
|
||||
|
||||
func testCompactedBidirectionalCollection() {
|
||||
for array in self.tests {
|
||||
XCTAssertEqualSequences(array.compactMap({ $0 }).reversed(),
|
||||
array.compacted().reversed())
|
||||
XCTAssertEqualSequences(
|
||||
array.compactMap({ $0 }).reversed(),
|
||||
array.compacted().reversed())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testCollectionTraversals() {
|
||||
for array in self.tests {
|
||||
validateIndexTraversals(array.compacted())
|
||||
|
||||
@@ -9,8 +9,8 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class CycleTests: XCTestCase {
|
||||
func testCycle() {
|
||||
@@ -73,8 +73,9 @@ final class CycleTests: XCTestCase {
|
||||
nextIndex = cycle.index(nextIndex, offsetBy: 2, limitedBy: cycle.endIndex)!
|
||||
XCTAssertEqual(cycle.distance(from: startIndex, to: nextIndex), 8)
|
||||
|
||||
let outOfBounds = cycle.index(nextIndex, offsetBy: 1,
|
||||
limitedBy: cycle.endIndex)
|
||||
let outOfBounds = cycle.index(
|
||||
nextIndex, offsetBy: 1,
|
||||
limitedBy: cycle.endIndex)
|
||||
XCTAssertNil(outOfBounds)
|
||||
|
||||
let previousIndex = cycle.index(before: nextIndex)
|
||||
|
||||
@@ -9,8 +9,8 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class FirstNonNilTests: XCTestCase {
|
||||
func testFirstNonNil() {
|
||||
|
||||
@@ -9,8 +9,8 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class IndexedTests: XCTestCase {
|
||||
func testIndexed() {
|
||||
@@ -27,7 +27,7 @@ final class IndexedTests: XCTestCase {
|
||||
let indexOfI = si.last(where: { $0.element == "I" })!.index
|
||||
XCTAssertEqual("I", s[indexOfI])
|
||||
}
|
||||
|
||||
|
||||
func testIndexedLazy() {
|
||||
XCTAssertLazyCollection("ABCD".lazy.indexed())
|
||||
}
|
||||
|
||||
@@ -9,13 +9,13 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class IntersperseTests: XCTestCase {
|
||||
func testSequence() {
|
||||
let interspersed = (1...).prefix(5).interspersed(with: 0)
|
||||
XCTAssertEqualSequences(interspersed, [1,0,2,0,3,0,4,0,5])
|
||||
XCTAssertEqualSequences(interspersed, [1, 0, 2, 0, 3, 0, 4, 0, 5])
|
||||
}
|
||||
|
||||
func testSequenceEmpty() {
|
||||
@@ -36,8 +36,8 @@ final class IntersperseTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testArray() {
|
||||
let interspersed = [1,2,3,4].interspersed(with: 0)
|
||||
XCTAssertEqualSequences(interspersed, [1,0,2,0,3,0,4])
|
||||
let interspersed = [1, 2, 3, 4].interspersed(with: 0)
|
||||
XCTAssertEqualSequences(interspersed, [1, 0, 2, 0, 3, 0, 4])
|
||||
validateIndexTraversals(interspersed)
|
||||
}
|
||||
|
||||
@@ -48,7 +48,7 @@ final class IntersperseTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testCollection() {
|
||||
let interspersed = ["A","B","C","D"].interspersed(with: "-")
|
||||
let interspersed = ["A", "B", "C", "D"].interspersed(with: "-")
|
||||
XCTAssertEqual(interspersed.count, 7)
|
||||
}
|
||||
|
||||
|
||||
@@ -112,7 +112,7 @@ final class LazySplitTests: XCTestCase {
|
||||
|
||||
func testAllEEES() {
|
||||
let permutations = [
|
||||
[1, 1, 1, 0], [1, 1, 0, 1], [1, 0, 1, 1], [0, 1, 1, 1]
|
||||
[1, 1, 1, 0], [1, 1, 0, 1], [1, 0, 1, 1], [0, 1, 1, 1],
|
||||
]
|
||||
|
||||
for permutation in permutations {
|
||||
|
||||
@@ -9,8 +9,8 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class SortedPrefixTests: XCTestCase {
|
||||
func testMinCount() {
|
||||
@@ -25,7 +25,7 @@ final class SortedPrefixTests: XCTestCase {
|
||||
.max(count: 5, sortedBy: { $0.element < $1.element })
|
||||
XCTAssertEqualSequences(maxZeroes.map { $0.offset }, 95..<100)
|
||||
}
|
||||
|
||||
|
||||
func testMaxCount() {
|
||||
// Replacement at start and end
|
||||
let input = [0, 11, 12, 1, 13, 2, 14, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
@@ -38,12 +38,12 @@ final class SortedPrefixTests: XCTestCase {
|
||||
.max(count: 5, sortedBy: { $0.element < $1.element })
|
||||
XCTAssertEqualSequences(maxZeroes.map { $0.offset }, 95..<100)
|
||||
}
|
||||
|
||||
|
||||
func testEmpty() {
|
||||
let array = [Int]()
|
||||
XCTAssertEqual(array.min(count: 0), [])
|
||||
XCTAssertEqual(array.min(count: 100), [])
|
||||
|
||||
|
||||
XCTAssertEqual(array.max(count: 0), [])
|
||||
XCTAssertEqual(array.max(count: 100), [])
|
||||
}
|
||||
@@ -51,14 +51,14 @@ final class SortedPrefixTests: XCTestCase {
|
||||
func testMinMaxSequences() {
|
||||
let input = (1...100).shuffled().interspersed(with: 50)
|
||||
let seq = AnySequence(input)
|
||||
|
||||
|
||||
XCTAssertEqualSequences(seq.min(count: 0), [])
|
||||
XCTAssertEqualSequences(seq.min(count: 5), 1...5)
|
||||
|
||||
|
||||
XCTAssertEqualSequences(seq.max(count: 0), [])
|
||||
XCTAssertEqualSequences(seq.max(count: 5), 96...100)
|
||||
}
|
||||
|
||||
|
||||
func testSortedPrefixComparable() {
|
||||
let array: [Int] = [20, 1, 4, 70, 100, 2, 3, 7, 90]
|
||||
|
||||
@@ -67,7 +67,7 @@ final class SortedPrefixTests: XCTestCase {
|
||||
XCTAssertEqualSequences(array.min(count: 5), array.sorted().prefix(5))
|
||||
XCTAssertEqual(array.min(count: 10), array.sorted())
|
||||
}
|
||||
|
||||
|
||||
func testMinMaxWithHugeCount() {
|
||||
XCTAssertEqual([4, 2, 1, 3].min(count: .max), [1, 2, 3, 4])
|
||||
XCTAssertEqual([4, 2, 1, 3].max(count: .max), [1, 2, 3, 4])
|
||||
@@ -130,10 +130,10 @@ final class SortedPrefixTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testStability() {
|
||||
assertStability([1,1,1,2,5,7,3,6,2,5,7,3,6], withCount: 3)
|
||||
assertStability([1,1,1,2,5,7,3,6,2,5,7,3,6], withCount: 6)
|
||||
assertStability([1,1,1,2,5,7,3,6,2,5,7,3,6], withCount: 20)
|
||||
assertStability([1,1,1,2,5,7,3,6,2,5,7,3,6], withCount: 1000)
|
||||
assertStability([1, 1, 1, 2, 5, 7, 3, 6, 2, 5, 7, 3, 6], withCount: 3)
|
||||
assertStability([1, 1, 1, 2, 5, 7, 3, 6, 2, 5, 7, 3, 6], withCount: 6)
|
||||
assertStability([1, 1, 1, 2, 5, 7, 3, 6, 2, 5, 7, 3, 6], withCount: 20)
|
||||
assertStability([1, 1, 1, 2, 5, 7, 3, 6, 2, 5, 7, 3, 6], withCount: 1000)
|
||||
assertStability(Array(repeating: 0, count: 100), withCount: 0)
|
||||
assertStability(Array(repeating: 0, count: 100), withCount: 1)
|
||||
assertStability(Array(repeating: 0, count: 100), withCount: 2)
|
||||
@@ -144,19 +144,19 @@ final class SortedPrefixTests: XCTestCase {
|
||||
assertStability(Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50), withCount: 5)
|
||||
assertStability(Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50), withCount: 20)
|
||||
assertStability(Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50), withCount: 50)
|
||||
assertStability([0,0], withCount: 1)
|
||||
assertStability([0,0], withCount: 2)
|
||||
assertStability([0,1,0,1,0,1], withCount: 2)
|
||||
assertStability([0,1,0,1,0,1], withCount: 6)
|
||||
assertStability([0,0,0,1,1,1], withCount: 1)
|
||||
assertStability([0,0,0,1,1,1], withCount: 3)
|
||||
assertStability([0,0,0,1,1,1], withCount: 4)
|
||||
assertStability([0,0,0,1,1,1], withCount: 6)
|
||||
assertStability([1,1,1,0,0,0], withCount: 1)
|
||||
assertStability([1,1,1,0,0,0], withCount: 3)
|
||||
assertStability([1,1,1,0,0,0], withCount: 4)
|
||||
assertStability([1,1,1,0,0,0], withCount: 6)
|
||||
assertStability([1,1,1,0,0,0], withCount: 5)
|
||||
assertStability([0, 0], withCount: 1)
|
||||
assertStability([0, 0], withCount: 2)
|
||||
assertStability([0, 1, 0, 1, 0, 1], withCount: 2)
|
||||
assertStability([0, 1, 0, 1, 0, 1], withCount: 6)
|
||||
assertStability([0, 0, 0, 1, 1, 1], withCount: 1)
|
||||
assertStability([0, 0, 0, 1, 1, 1], withCount: 3)
|
||||
assertStability([0, 0, 0, 1, 1, 1], withCount: 4)
|
||||
assertStability([0, 0, 0, 1, 1, 1], withCount: 6)
|
||||
assertStability([1, 1, 1, 0, 0, 0], withCount: 1)
|
||||
assertStability([1, 1, 1, 0, 0, 0], withCount: 3)
|
||||
assertStability([1, 1, 1, 0, 0, 0], withCount: 4)
|
||||
assertStability([1, 1, 1, 0, 0, 0], withCount: 6)
|
||||
assertStability([1, 1, 1, 0, 0, 0], withCount: 5)
|
||||
}
|
||||
|
||||
func assertStability(
|
||||
@@ -165,19 +165,19 @@ final class SortedPrefixTests: XCTestCase {
|
||||
) {
|
||||
func stableOrder(
|
||||
a: (offset: Int, element: Int),
|
||||
b: (offset: Int, element: Int)) -> Bool
|
||||
{
|
||||
b: (offset: Int, element: Int)
|
||||
) -> Bool {
|
||||
a.element == b.element
|
||||
? a.offset < b.offset
|
||||
: a.element < b.element
|
||||
}
|
||||
|
||||
|
||||
do {
|
||||
let sorted = actual.enumerated()
|
||||
.min(count: count) { $0.element < $1.element }
|
||||
XCTAssert(sorted.isSorted(by: stableOrder))
|
||||
}
|
||||
|
||||
|
||||
do {
|
||||
let sorted = actual.enumerated()
|
||||
.max(count: count) { $0.element < $1.element }
|
||||
|
||||
@@ -9,8 +9,8 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class PartitionTests: XCTestCase {
|
||||
func testStablePartition() {
|
||||
@@ -60,7 +60,7 @@ final class PartitionTests: XCTestCase {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testStablePartitionWithSubrange() {
|
||||
for length in 10...20 {
|
||||
let a = Array(0..<length)
|
||||
@@ -72,13 +72,15 @@ final class PartitionTests: XCTestCase {
|
||||
let p = b.stablePartition(subrange: partitionRange, by: condition)
|
||||
|
||||
XCTAssertEqual(p, partitionRange.count == 0 ? j : j + 1)
|
||||
XCTAssertEqualSequences(b[partitionRange.lowerBound..<p], a[partitionRange].filter { !condition($0) })
|
||||
XCTAssertEqualSequences(b[p..<partitionRange.upperBound], a[partitionRange].filter(condition))
|
||||
XCTAssertEqualSequences(
|
||||
b[partitionRange.lowerBound..<p], a[partitionRange].filter { !condition($0) })
|
||||
XCTAssertEqualSequences(
|
||||
b[p..<partitionRange.upperBound], a[partitionRange].filter(condition))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testPartitioningIndex() {
|
||||
for i in 0..<7 {
|
||||
for j in i..<11 {
|
||||
@@ -91,7 +93,7 @@ final class PartitionTests: XCTestCase {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testPartitionWithSubrangeBidirectionalCollection() {
|
||||
for length in 10...20 {
|
||||
let a = Array(0..<length)
|
||||
@@ -101,10 +103,12 @@ final class PartitionTests: XCTestCase {
|
||||
let partitionRange = j..<i
|
||||
let condition = { $0 < i - 1 }
|
||||
let p = b.partition(subrange: partitionRange, by: condition)
|
||||
|
||||
|
||||
XCTAssertEqual(p, partitionRange.count == 0 ? j : j + 1)
|
||||
XCTAssertEqualSequences(b[partitionRange.lowerBound..<p], a[partitionRange].filter { !condition($0) })
|
||||
XCTAssertUnorderedEqualSequences(b[p..<partitionRange.upperBound], a[partitionRange].filter(condition))
|
||||
XCTAssertEqualSequences(
|
||||
b[partitionRange.lowerBound..<p], a[partitionRange].filter { !condition($0) })
|
||||
XCTAssertUnorderedEqualSequences(
|
||||
b[p..<partitionRange.upperBound], a[partitionRange].filter(condition))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -121,14 +125,18 @@ final class PartitionTests: XCTestCase {
|
||||
let condition = { $0 < i - 1 }
|
||||
let p = b.partition(subrange: partitionRange, by: condition)
|
||||
let bdcp = bdc.partition(subrange: partitionRange, by: condition)
|
||||
|
||||
|
||||
XCTAssertEqual(p, partitionRange.count == 0 ? j : j + 1)
|
||||
XCTAssertEqualSequences(b[partitionRange.lowerBound..<p], a[partitionRange].filter { !condition($0) })
|
||||
XCTAssertUnorderedEqualSequences(b[p..<partitionRange.upperBound], a[partitionRange].filter(condition))
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
b[partitionRange.lowerBound..<p], a[partitionRange].filter { !condition($0) })
|
||||
XCTAssertUnorderedEqualSequences(
|
||||
b[p..<partitionRange.upperBound], a[partitionRange].filter(condition))
|
||||
|
||||
// Must produce the same result as the `BidirectionalCollection` specialized overload.
|
||||
XCTAssertEqualSequences(b[partitionRange.lowerBound..<p], bdc[partitionRange.lowerBound..<bdcp])
|
||||
XCTAssertUnorderedEqualSequences(b[p..<partitionRange.upperBound], bdc[bdcp..<partitionRange.upperBound])
|
||||
XCTAssertEqualSequences(
|
||||
b[partitionRange.lowerBound..<p], bdc[partitionRange.lowerBound..<bdcp])
|
||||
XCTAssertUnorderedEqualSequences(
|
||||
b[p..<partitionRange.upperBound], bdc[bdcp..<partitionRange.upperBound])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,15 +10,16 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
|
||||
@testable import Algorithms
|
||||
|
||||
final class PermutationsTests: XCTestCase {
|
||||
func testPermutations() {
|
||||
let c = "ABCDE"
|
||||
|
||||
|
||||
func t(count: Int?) {
|
||||
let p = c.permutations(ofCount: count)
|
||||
|
||||
|
||||
let count = count ?? c.count
|
||||
let permCount = c.count.factorial() / (c.count - count).factorial()
|
||||
XCTAssertEqual(permCount, p.count)
|
||||
@@ -26,20 +27,20 @@ final class PermutationsTests: XCTestCase {
|
||||
XCTAssertTrue(p.allSatisfy { $0.count == count })
|
||||
XCTAssertTrue(p.isSorted(by: { $0.lexicographicallyPrecedes($1) }))
|
||||
}
|
||||
|
||||
|
||||
func ts<R: RangeExpression>(count: R) where R.Bound == Int {
|
||||
let p = count.relative(to: 0 ..< .max)
|
||||
.clamped(to: 0 ..< c.count + 1)
|
||||
.clamped(to: 0..<c.count + 1)
|
||||
.flatMap {
|
||||
c.permutations(ofCount: $0)
|
||||
}
|
||||
|
||||
|
||||
let p2 = c.permutations(ofCount: count)
|
||||
|
||||
|
||||
XCTAssertEqual(p.count, p2.count)
|
||||
XCTAssertEqualSequences(p, Array(p2))
|
||||
}
|
||||
|
||||
|
||||
t(count: 0)
|
||||
t(count: 1)
|
||||
t(count: 2)
|
||||
@@ -47,7 +48,7 @@ final class PermutationsTests: XCTestCase {
|
||||
t(count: 4)
|
||||
t(count: 5)
|
||||
t(count: nil)
|
||||
|
||||
|
||||
ts(count: 0...0)
|
||||
ts(count: 1...1)
|
||||
ts(count: 0...1)
|
||||
@@ -60,7 +61,7 @@ final class PermutationsTests: XCTestCase {
|
||||
ts(count: ...4)
|
||||
ts(count: ...6)
|
||||
}
|
||||
|
||||
|
||||
func testEmpty() {
|
||||
// `k == 0` results in one zero-length permutation
|
||||
XCTAssertEqual(1, "".permutations().count)
|
||||
@@ -70,7 +71,7 @@ final class PermutationsTests: XCTestCase {
|
||||
XCTAssertEqual(Array("".permutations(ofCount: 0)), [[]])
|
||||
XCTAssertEqual(Array("ABCD".permutations(ofCount: 0)), [[]])
|
||||
XCTAssertEqual(Array("ABCD".permutations(ofCount: 0...0)), [[]])
|
||||
|
||||
|
||||
// `k` greater than element count results in zero permutations
|
||||
XCTAssertEqual(0, "".permutations(ofCount: 5).count)
|
||||
XCTAssertEqual(Array("".permutations(ofCount: 5)), [])
|
||||
@@ -79,10 +80,10 @@ final class PermutationsTests: XCTestCase {
|
||||
XCTAssertEqual(Array("ABCD".permutations(ofCount: 5..<7)), [])
|
||||
XCTAssertEqual(Array("ABCD".permutations(ofCount: 5...)), [])
|
||||
}
|
||||
|
||||
|
||||
func testNextPermutation() {
|
||||
var numbers = Array(1...7)
|
||||
|
||||
|
||||
_ = numbers.nextPermutation()
|
||||
XCTAssertEqual([1, 2, 3, 4, 5, 7, 6], numbers)
|
||||
_ = numbers.nextPermutation()
|
||||
@@ -95,110 +96,122 @@ final class PermutationsTests: XCTestCase {
|
||||
XCTAssertEqual([1, 2, 3, 4, 7, 6, 5], numbers)
|
||||
_ = numbers.nextPermutation()
|
||||
XCTAssertEqual([1, 2, 3, 5, 4, 6, 7], numbers)
|
||||
|
||||
|
||||
// Fast-forward to end of permutations.
|
||||
while numbers.nextPermutation() {}
|
||||
XCTAssertEqual([1, 2, 3, 4, 5, 6, 7], numbers)
|
||||
}
|
||||
|
||||
|
||||
func testPermutationsLazy() {
|
||||
XCTAssertLazySequence("ABCD".lazy.permutations(ofCount: 2))
|
||||
}
|
||||
|
||||
|
||||
func testDocumentationExample1() {
|
||||
// From Guides/Permutations.md
|
||||
let numbers = [10, 20, 30]
|
||||
let permutations = numbers.permutations()
|
||||
XCTAssertEqualSequences(permutations, [
|
||||
[10, 20, 30],
|
||||
[10, 30, 20],
|
||||
[20, 10, 30],
|
||||
[20, 30, 10],
|
||||
[30, 10, 20],
|
||||
[30, 20, 10],
|
||||
])
|
||||
XCTAssertEqualSequences(
|
||||
permutations,
|
||||
[
|
||||
[10, 20, 30],
|
||||
[10, 30, 20],
|
||||
[20, 10, 30],
|
||||
[20, 30, 10],
|
||||
[30, 10, 20],
|
||||
[30, 20, 10],
|
||||
])
|
||||
}
|
||||
|
||||
|
||||
func testDocumentationExample2() {
|
||||
// From Guides/Permutations.md
|
||||
let numbers = [10, 20, 30]
|
||||
let permutations = numbers.permutations(ofCount: 2)
|
||||
XCTAssertEqualSequences(permutations, [
|
||||
[10, 20],
|
||||
[10, 30],
|
||||
[20, 10],
|
||||
[20, 30],
|
||||
[30, 10],
|
||||
[30, 20],
|
||||
])
|
||||
XCTAssertEqualSequences(
|
||||
permutations,
|
||||
[
|
||||
[10, 20],
|
||||
[10, 30],
|
||||
[20, 10],
|
||||
[20, 30],
|
||||
[30, 10],
|
||||
[30, 20],
|
||||
])
|
||||
}
|
||||
|
||||
|
||||
func testDocumentationExample3() {
|
||||
// From Guides/Permutations.md
|
||||
let numbers2 = [20, 10, 10]
|
||||
let permutations = numbers2.permutations()
|
||||
XCTAssertEqualSequences(permutations, [
|
||||
[20, 10, 10],
|
||||
[20, 10, 10],
|
||||
[10, 20, 10],
|
||||
[10, 10, 20],
|
||||
[10, 20, 10],
|
||||
[10, 10, 20],
|
||||
])
|
||||
XCTAssertEqualSequences(
|
||||
permutations,
|
||||
[
|
||||
[20, 10, 10],
|
||||
[20, 10, 10],
|
||||
[10, 20, 10],
|
||||
[10, 10, 20],
|
||||
[10, 20, 10],
|
||||
[10, 10, 20],
|
||||
])
|
||||
}
|
||||
|
||||
|
||||
func testDocumentationExample4() {
|
||||
// From Guides/Permutations.md
|
||||
let numbers = [10, 20, 30]
|
||||
let permutations = numbers.permutations(ofCount: 0...)
|
||||
XCTAssertEqualSequences(permutations, [
|
||||
[],
|
||||
[10],
|
||||
[20],
|
||||
[30],
|
||||
[10, 20],
|
||||
[10, 30],
|
||||
[20, 10],
|
||||
[20, 30],
|
||||
[30, 10],
|
||||
[30, 20],
|
||||
[10, 20, 30],
|
||||
[10, 30, 20],
|
||||
[20, 10, 30],
|
||||
[20, 30, 10],
|
||||
[30, 10, 20],
|
||||
[30, 20, 10],
|
||||
])
|
||||
XCTAssertEqualSequences(
|
||||
permutations,
|
||||
[
|
||||
[],
|
||||
[10],
|
||||
[20],
|
||||
[30],
|
||||
[10, 20],
|
||||
[10, 30],
|
||||
[20, 10],
|
||||
[20, 30],
|
||||
[30, 10],
|
||||
[30, 20],
|
||||
[10, 20, 30],
|
||||
[10, 30, 20],
|
||||
[20, 10, 30],
|
||||
[20, 30, 10],
|
||||
[30, 10, 20],
|
||||
[30, 20, 10],
|
||||
])
|
||||
}
|
||||
|
||||
|
||||
func testDocumentationExample5() {
|
||||
// From Permutations.swift
|
||||
let names = ["Alex", "Celeste", "Davide"]
|
||||
let permutations = names.permutations(ofCount: 2)
|
||||
XCTAssertEqualSequences(permutations, [
|
||||
["Alex", "Celeste"],
|
||||
["Alex", "Davide"],
|
||||
["Celeste", "Alex"],
|
||||
["Celeste", "Davide"],
|
||||
["Davide", "Alex"],
|
||||
["Davide", "Celeste"],
|
||||
])
|
||||
XCTAssertEqualSequences(
|
||||
permutations,
|
||||
[
|
||||
["Alex", "Celeste"],
|
||||
["Alex", "Davide"],
|
||||
["Celeste", "Alex"],
|
||||
["Celeste", "Davide"],
|
||||
["Davide", "Alex"],
|
||||
["Davide", "Celeste"],
|
||||
])
|
||||
}
|
||||
|
||||
|
||||
func testDocumentationExample6() {
|
||||
// From Permutations.swift
|
||||
let names = ["Alex", "Celeste", "Davide"]
|
||||
let permutations = names.permutations(ofCount: 1...2)
|
||||
XCTAssertEqualSequences(permutations, [
|
||||
["Alex"],
|
||||
["Celeste"],
|
||||
["Davide"],
|
||||
["Alex", "Celeste"],
|
||||
["Alex", "Davide"],
|
||||
["Celeste", "Alex"],
|
||||
["Celeste", "Davide"],
|
||||
["Davide", "Alex"],
|
||||
["Davide", "Celeste"],
|
||||
])
|
||||
XCTAssertEqualSequences(
|
||||
permutations,
|
||||
[
|
||||
["Alex"],
|
||||
["Celeste"],
|
||||
["Davide"],
|
||||
["Alex", "Celeste"],
|
||||
["Alex", "Davide"],
|
||||
["Celeste", "Alex"],
|
||||
["Celeste", "Davide"],
|
||||
["Davide", "Alex"],
|
||||
["Davide", "Celeste"],
|
||||
])
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
|
||||
@testable import Algorithms
|
||||
|
||||
final class ProductTests: XCTestCase {
|
||||
@@ -22,7 +23,7 @@ final class ProductTests: XCTestCase {
|
||||
XCTAssertEqualSequences(product(1...10, ""), [], by: ==)
|
||||
XCTAssertEqualSequences(product("", 1...10), [], by: ==)
|
||||
}
|
||||
|
||||
|
||||
func testProductReversed() {
|
||||
XCTAssertEqualSequences(
|
||||
[(2, "B" as Character), (2, "A"), (1, "B"), (1, "A")],
|
||||
@@ -32,12 +33,12 @@ final class ProductTests: XCTestCase {
|
||||
XCTAssertEqualSequences(product(1...10, "").reversed(), [], by: ==)
|
||||
XCTAssertEqualSequences(product("", 1...10).reversed(), [], by: ==)
|
||||
}
|
||||
|
||||
|
||||
func testProductDistanceFromTo() {
|
||||
let p = product([1, 2], "abc")
|
||||
XCTAssertEqual(p.distance(from: p.startIndex, to: p.endIndex), 6)
|
||||
}
|
||||
|
||||
|
||||
func testProductIndexTraversals() {
|
||||
validateIndexTraversals(
|
||||
product([1, 2, 3, 4], "abc"),
|
||||
|
||||
@@ -10,6 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
|
||||
@testable import Algorithms
|
||||
|
||||
func validateRandomSamples<S: Sequence>(
|
||||
@@ -18,8 +19,9 @@ func validateRandomSamples<S: Sequence>(
|
||||
expectedValue: Int,
|
||||
file: StaticString = #file, line: UInt = #line
|
||||
) where S.Element == Int {
|
||||
let expectedRange = ((expectedValue / 3) * 2) ... ((expectedValue / 3) * 4)
|
||||
XCTAssertEqualSequences(samples.keys.sorted(), elements,
|
||||
let expectedRange = ((expectedValue / 3) * 2)...((expectedValue / 3) * 4)
|
||||
XCTAssertEqualSequences(
|
||||
samples.keys.sorted(), elements,
|
||||
file: file, line: line)
|
||||
for v in samples.values {
|
||||
XCTAssert(expectedRange.contains(v), file: file, line: line)
|
||||
@@ -43,7 +45,7 @@ final class RandomSampleTests: XCTestCase {
|
||||
}
|
||||
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) {
|
||||
@@ -52,7 +54,7 @@ final class RandomSampleTests: XCTestCase {
|
||||
}
|
||||
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) {
|
||||
@@ -61,7 +63,7 @@ final class RandomSampleTests: XCTestCase {
|
||||
}
|
||||
validateRandomSamples(samples, elements: s, expectedValue: (k * iterations) / n)
|
||||
}
|
||||
|
||||
|
||||
func testRandomSampleEdgeCases() {
|
||||
XCTAssert(c.randomStableSample(count: 0).isEmpty)
|
||||
XCTAssertEqualSequences(c.randomStableSample(count: n), c)
|
||||
@@ -70,12 +72,12 @@ final class RandomSampleTests: XCTestCase {
|
||||
XCTAssert(c.randomSample(count: 0).isEmpty)
|
||||
XCTAssertEqualSequences(c.randomSample(count: n).sorted(), c)
|
||||
XCTAssertEqualSequences(c.randomSample(count: n * 2).sorted(), c)
|
||||
|
||||
|
||||
XCTAssert(s.randomSample(count: 0).isEmpty)
|
||||
XCTAssertEqualSequences(s.randomSample(count: n).sorted(), c)
|
||||
XCTAssertEqualSequences(s.randomSample(count: n * 2).sorted(), c)
|
||||
}
|
||||
|
||||
|
||||
func testRandomSampleRepeatable() {
|
||||
var generator = SplitMix64(seed: 0)
|
||||
let sample1a = c.randomSample(count: k, using: &generator)
|
||||
@@ -88,7 +90,7 @@ final class RandomSampleTests: XCTestCase {
|
||||
generator = SplitMix64(seed: 0)
|
||||
let sample2b = s.randomSample(count: k, using: &generator)
|
||||
XCTAssertEqual(sample1b, sample2b)
|
||||
|
||||
|
||||
generator = SplitMix64(seed: 0)
|
||||
let sample1c = c.randomStableSample(count: k, using: &generator)
|
||||
generator = SplitMix64(seed: 0)
|
||||
@@ -101,7 +103,7 @@ final class RandomSampleTests: XCTestCase {
|
||||
mutating func next() -> UInt64 { 0 }
|
||||
}
|
||||
var zero = ZeroGenerator()
|
||||
_ = nextOffset(w: 1, using: &zero) // must not crash
|
||||
_ = nextOffset(w: 1, using: &zero) // must not crash
|
||||
|
||||
struct AlmostAllZeroGenerator: RandomNumberGenerator {
|
||||
private var forward: SplitMix64
|
||||
@@ -119,8 +121,8 @@ final class RandomSampleTests: XCTestCase {
|
||||
}
|
||||
|
||||
var almostAllZero = AlmostAllZeroGenerator(seed: 0)
|
||||
_ = s.randomSample(count: k, using: &almostAllZero) // must not crash
|
||||
_ = s.randomSample(count: k, using: &almostAllZero) // must not crash
|
||||
almostAllZero = AlmostAllZeroGenerator(seed: 0)
|
||||
_ = c.randomSample(count: k, using: &almostAllZero) // must not crash
|
||||
_ = c.randomSample(count: k, using: &almostAllZero) // must not crash
|
||||
}
|
||||
}
|
||||
@@ -9,8 +9,8 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class ReductionsTests: XCTestCase {
|
||||
|
||||
|
||||
@@ -10,6 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
|
||||
@testable import Algorithms
|
||||
|
||||
final class RotateTests: XCTestCase {
|
||||
@@ -17,20 +18,21 @@ final class RotateTests: XCTestCase {
|
||||
func testUnderscoreReverse() {
|
||||
var input = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p"]
|
||||
let limit: Int = 4
|
||||
let (lower, upper) = input._reverse(subrange: input.startIndex..<input.endIndex, until: input.startIndex.advanced(by: limit))
|
||||
let (lower, upper) = input._reverse(
|
||||
subrange: input.startIndex..<input.endIndex, until: input.startIndex.advanced(by: limit))
|
||||
let expected = ["p", "o", "n", "m", "e", "f", "g", "h", "i", "j", "k", "l", "d", "c", "b", "a"]
|
||||
XCTAssertEqual(input, expected)
|
||||
XCTAssertEqual(lower, input.startIndex.advanced(by: limit))
|
||||
XCTAssertEqual(upper, input.endIndex.advanced(by: -limit))
|
||||
}
|
||||
|
||||
|
||||
/// Tests the example given in `reverse(subrange:)`’s documentation
|
||||
func testReverse() {
|
||||
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
numbers.reverse(subrange: 0..<4)
|
||||
XCTAssertEqual(numbers, [40, 30, 20, 10, 50, 60, 70, 80])
|
||||
}
|
||||
|
||||
|
||||
/// Tests `rotate(subrange:toStartAt:)` with an empty subrange
|
||||
/// The order of elements are unchanged
|
||||
func testRotateEmptySubrange() {
|
||||
@@ -39,7 +41,7 @@ final class RotateTests: XCTestCase {
|
||||
XCTAssertEqual(numbers, [10, 20, 30, 40, 50, 60, 70, 80])
|
||||
XCTAssertEqual(numbers[oldStart], 40)
|
||||
}
|
||||
|
||||
|
||||
/// Tests `rotate(subrange:toStartAt:)` with an empty collection
|
||||
func testRotateSubrangeOnEmptyCollection() {
|
||||
var numbers = [Int]()
|
||||
@@ -47,7 +49,7 @@ final class RotateTests: XCTestCase {
|
||||
XCTAssertEqual(numbers, [])
|
||||
XCTAssertEqual(oldStart, numbers.startIndex)
|
||||
}
|
||||
|
||||
|
||||
/// Tests `rotate(subrange:toStartAt:)` with the full range of the collection
|
||||
func testRotateFullRange() {
|
||||
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
@@ -55,7 +57,7 @@ final class RotateTests: XCTestCase {
|
||||
XCTAssertEqual(numbers, [20, 30, 40, 50, 60, 70, 80, 10])
|
||||
XCTAssertEqual(numbers[oldStart], 10)
|
||||
}
|
||||
|
||||
|
||||
/// Tests the example given in `rotate(subrange:toStartAt:)`’s documentation
|
||||
func testRotateSubrange() {
|
||||
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
@@ -63,7 +65,7 @@ final class RotateTests: XCTestCase {
|
||||
XCTAssertEqual(numbers, [30, 40, 10, 20, 50, 60, 70, 80])
|
||||
XCTAssertEqual(numbers[oldStart], 10)
|
||||
}
|
||||
|
||||
|
||||
/// Tests the example given in `rotate(toStartAt:)`’s documentation
|
||||
func testRotateExample() {
|
||||
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
@@ -71,7 +73,7 @@ final class RotateTests: XCTestCase {
|
||||
XCTAssertEqual(numbers, [40, 50, 60, 70, 80, 10, 20, 30])
|
||||
XCTAssertEqual(numbers[oldStart], 10)
|
||||
}
|
||||
|
||||
|
||||
/// Tests `rotate(toStartAt:)` on collections of varying lengths, at different
|
||||
/// starting points
|
||||
func testRotate() {
|
||||
|
||||
@@ -9,11 +9,11 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class StridingTests: XCTestCase {
|
||||
|
||||
|
||||
func testStride() {
|
||||
let a = 0...10
|
||||
XCTAssertEqualSequences(a.striding(by: 1), (0...10))
|
||||
@@ -23,7 +23,7 @@ final class StridingTests: XCTestCase {
|
||||
XCTAssertEqualSequences(a.striding(by: 5), [0, 5, 10])
|
||||
XCTAssertEqualSequences(a.striding(by: 10), [0, 10])
|
||||
XCTAssertEqualSequences(a.striding(by: 11), [0])
|
||||
|
||||
|
||||
let s = (0...).prefix(11)
|
||||
XCTAssertEqualSequences(s.striding(by: 1), (0...10))
|
||||
XCTAssertEqualSequences(s.striding(by: 2), [0, 2, 4, 6, 8, 10])
|
||||
@@ -32,22 +32,22 @@ final class StridingTests: XCTestCase {
|
||||
XCTAssertEqualSequences(s.striding(by: 5), [0, 5, 10])
|
||||
XCTAssertEqualSequences(s.striding(by: 10), [0, 10])
|
||||
XCTAssertEqualSequences(s.striding(by: 11), [0])
|
||||
|
||||
|
||||
let empty = (0...).prefix(0)
|
||||
XCTAssertEqualSequences(empty.striding(by: 2), [])
|
||||
}
|
||||
|
||||
|
||||
func testStrideString() {
|
||||
let s = "swift"
|
||||
XCTAssertEqualSequences(s.striding(by: 2), ["s", "i", "t"])
|
||||
}
|
||||
|
||||
|
||||
func testStrideReversed() {
|
||||
let a = [0, 1, 2, 3, 4, 5]
|
||||
XCTAssertEqualSequences(a.striding(by: 3).reversed(), [3, 0])
|
||||
XCTAssertEqualSequences(a.reversed().striding(by: 2), [5, 3, 1])
|
||||
}
|
||||
|
||||
|
||||
func testStrideIndexes() {
|
||||
let a = [0, 1, 2, 3, 4, 5].striding(by: 2)
|
||||
var i = a.startIndex
|
||||
@@ -60,20 +60,20 @@ final class StridingTests: XCTestCase {
|
||||
XCTAssertEqual(a[i], 2)
|
||||
a.formIndex(before: &i)
|
||||
XCTAssertEqual(a[i], 0)
|
||||
// a.formIndex(before: &i) // Precondition failed: Incrementing past start index
|
||||
// a.index(after: a.endIndex) // Precondition failed: Advancing past end index
|
||||
// a.formIndex(before: &i) // Precondition failed: Incrementing past start index
|
||||
// a.index(after: a.endIndex) // Precondition failed: Advancing past end index
|
||||
}
|
||||
|
||||
|
||||
func testStrideLast() {
|
||||
XCTAssertEqual((1...10).striding(by: 2).last, 9) // 1, 3, 5, 7, 9
|
||||
XCTAssertEqual((1...10).striding(by: 3).last, 10) // 1, 4, 7, 10
|
||||
XCTAssertEqual((1...10).striding(by: 4).last, 9) // 1, 5, 9
|
||||
XCTAssertEqual((1...10).striding(by: 5).last, 6) // 1, 6
|
||||
XCTAssertEqual((1...100).striding(by: 50).last, 51) // 1, 51
|
||||
XCTAssertEqual((1...5).striding(by: 2).last, 5) // 1, 3, 5
|
||||
XCTAssertEqual([Int]().striding(by: 2).last, nil) // empty
|
||||
XCTAssertEqual((1...10).striding(by: 2).last, 9) // 1, 3, 5, 7, 9
|
||||
XCTAssertEqual((1...10).striding(by: 3).last, 10) // 1, 4, 7, 10
|
||||
XCTAssertEqual((1...10).striding(by: 4).last, 9) // 1, 5, 9
|
||||
XCTAssertEqual((1...10).striding(by: 5).last, 6) // 1, 6
|
||||
XCTAssertEqual((1...100).striding(by: 50).last, 51) // 1, 51
|
||||
XCTAssertEqual((1...5).striding(by: 2).last, 5) // 1, 3, 5
|
||||
XCTAssertEqual([Int]().striding(by: 2).last, nil) // empty
|
||||
}
|
||||
|
||||
|
||||
func testCount() {
|
||||
let empty = [Int]().striding(by: 2)
|
||||
XCTAssertEqual(empty.count, 0)
|
||||
@@ -86,7 +86,7 @@ final class StridingTests: XCTestCase {
|
||||
XCTAssertEqual(a.striding(by: 10).count, [0, 10].count)
|
||||
XCTAssertEqual(a.striding(by: 11).count, [0].count)
|
||||
}
|
||||
|
||||
|
||||
func testIndexTraversals() {
|
||||
let empty = [Int]()
|
||||
validateIndexTraversals(
|
||||
@@ -113,7 +113,6 @@ final class StridingTests: XCTestCase {
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
func testOffsetBy() {
|
||||
let a = (0...100).striding(by: 22)
|
||||
let b = [0, 22, 44, 66, 88]
|
||||
@@ -121,10 +120,10 @@ final class StridingTests: XCTestCase {
|
||||
XCTAssertEqual(a[a.index(a.startIndex, offsetBy: i)], b[i])
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testOffsetByEndIndex() {
|
||||
let a = 1...5
|
||||
let b = a.striding(by: 3) // [1, 4]
|
||||
let b = a.striding(by: 3) // [1, 4]
|
||||
let i = b.index(b.startIndex, offsetBy: 2)
|
||||
XCTAssertEqual(i, b.endIndex)
|
||||
}
|
||||
|
||||
@@ -10,6 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
|
||||
@testable import Algorithms
|
||||
|
||||
final class SuffixTests: XCTestCase {
|
||||
@@ -19,29 +20,29 @@ final class SuffixTests: XCTestCase {
|
||||
XCTAssertEqualSequences(a.suffix(while: { $0 > 10 }), [])
|
||||
XCTAssertEqualSequences(a.suffix(while: { $0 > 9 }), [10])
|
||||
XCTAssertEqualSequences(a.suffix(while: { $0 > -1 }), (0...10))
|
||||
|
||||
|
||||
let empty: [Int] = []
|
||||
XCTAssertEqualSequences(empty.suffix(while: { $0 > 10 }), [])
|
||||
}
|
||||
|
||||
|
||||
func testEndOfPrefix() {
|
||||
let array = Array(0..<10)
|
||||
XCTAssertEqual(array.endOfPrefix(while: { $0 < 3 }), 3)
|
||||
XCTAssertEqual(array.endOfPrefix(while: { _ in false }), array.startIndex)
|
||||
XCTAssertEqual(array.endOfPrefix(while: { _ in true }), array.endIndex)
|
||||
|
||||
|
||||
let empty = [Int]()
|
||||
XCTAssertEqual(empty.endOfPrefix(while: { $0 < 3 }), 0)
|
||||
XCTAssertEqual(empty.endOfPrefix(while: { _ in false }), empty.startIndex)
|
||||
XCTAssertEqual(empty.endOfPrefix(while: { _ in true }), empty.endIndex)
|
||||
}
|
||||
|
||||
|
||||
func testStartOfSuffix() {
|
||||
let array = Array(0..<10)
|
||||
XCTAssertEqual(array.startOfSuffix(while: { $0 >= 3 }), 3)
|
||||
XCTAssertEqual(array.startOfSuffix(while: { _ in false }), array.endIndex)
|
||||
XCTAssertEqual(array.startOfSuffix(while: { _ in true }), array.startIndex)
|
||||
|
||||
|
||||
let empty = [Int]()
|
||||
XCTAssertEqual(empty.startOfSuffix(while: { $0 < 3 }), 0)
|
||||
XCTAssertEqual(empty.startOfSuffix(while: { _ in false }), empty.endIndex)
|
||||
|
||||
@@ -32,16 +32,16 @@ extension Numeric {
|
||||
|
||||
struct SplitMix64: RandomNumberGenerator {
|
||||
private var state: UInt64
|
||||
|
||||
|
||||
init(seed: UInt64) {
|
||||
self.state = seed
|
||||
}
|
||||
|
||||
|
||||
mutating func next() -> UInt64 {
|
||||
self.state &+= 0x9e3779b97f4a7c15
|
||||
self.state &+= 0x9e37_79b9_7f4a_7c15
|
||||
var z: UInt64 = self.state
|
||||
z = (z ^ (z &>> 30)) &* 0xbf58476d1ce4e5b9
|
||||
z = (z ^ (z &>> 27)) &* 0x94d049bb133111eb
|
||||
z = (z ^ (z &>> 30)) &* 0xbf58_476d_1ce4_e5b9
|
||||
z = (z ^ (z &>> 27)) &* 0x94d0_49bb_1331_11eb
|
||||
return z ^ (z &>> 31)
|
||||
}
|
||||
}
|
||||
@@ -54,7 +54,7 @@ struct AnyMutableCollection<Base> where Base: MutableCollection {
|
||||
extension AnyMutableCollection: MutableCollection {
|
||||
typealias Index = Base.Index
|
||||
typealias Element = Base.Element
|
||||
|
||||
|
||||
var startIndex: Base.Index { base.startIndex }
|
||||
var endIndex: Base.Index { base.endIndex }
|
||||
|
||||
@@ -80,7 +80,8 @@ func XCTAssertEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
_ message: @autoclosure () -> String = "",
|
||||
file: StaticString = #file, line: UInt = #line
|
||||
) rethrows where S1.Element: Equatable, S1.Element == S2.Element {
|
||||
try XCTAssertEqualSequences(expression1(), expression2(), by: ==,
|
||||
try XCTAssertEqualSequences(
|
||||
expression1(), expression2(), by: ==,
|
||||
message(), file: file, line: line)
|
||||
}
|
||||
|
||||
@@ -99,7 +100,7 @@ func XCTAssertUnorderedEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
}
|
||||
s1.remove(at: idx)
|
||||
}
|
||||
|
||||
|
||||
XCTAssertTrue(
|
||||
missing.isEmpty, "first sequence missing '\(missing)' elements from second sequence",
|
||||
file: file, line: line
|
||||
@@ -121,8 +122,9 @@ func XCTAssertEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
|
||||
func fail(_ reason: String) {
|
||||
let message = message()
|
||||
XCTFail(message.isEmpty ? reason : "\(message) - \(reason)",
|
||||
file: file, line: line)
|
||||
XCTFail(
|
||||
message.isEmpty ? reason : "\(message) - \(reason)",
|
||||
file: file, line: line)
|
||||
}
|
||||
|
||||
var iter1 = try expression1().makeIterator()
|
||||
@@ -134,7 +136,9 @@ func XCTAssertEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
idx += 1
|
||||
continue
|
||||
case let (e1?, e2?):
|
||||
fail("element \(e1) on first sequence does not match element \(e2) on second sequence at position \(idx)")
|
||||
fail(
|
||||
"element \(e1) on first sequence does not match element \(e2) on second sequence at position \(idx)"
|
||||
)
|
||||
case (_?, nil):
|
||||
fail("second sequence shorter than first")
|
||||
case (nil, _?):
|
||||
@@ -190,7 +194,7 @@ func validateIndexTraversals<C>(
|
||||
for c in collections {
|
||||
let indicesIncludingEnd = indices?(c) ?? (c.indices + [c.endIndex])
|
||||
let count = indicesIncludingEnd.count - 1
|
||||
|
||||
|
||||
XCTAssertEqual(
|
||||
c.count, count,
|
||||
"Count mismatch",
|
||||
@@ -207,11 +211,11 @@ func validateIndexTraversals<C>(
|
||||
c.endIndex, indicesIncludingEnd.last,
|
||||
"`endIndex` does not equal the last index",
|
||||
file: file, line: line)
|
||||
|
||||
|
||||
// `index(after:)`
|
||||
do {
|
||||
var index = c.startIndex
|
||||
|
||||
|
||||
for (offset, expected) in indicesIncludingEnd.enumerated().dropFirst() {
|
||||
c.formIndex(after: &index)
|
||||
XCTAssertEqual(
|
||||
@@ -223,7 +227,7 @@ func validateIndexTraversals<C>(
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// `index(before:)`
|
||||
do {
|
||||
var index = c.endIndex
|
||||
@@ -239,7 +243,7 @@ func validateIndexTraversals<C>(
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// `indices`
|
||||
XCTAssertEqual(c.indices.count, count)
|
||||
for (offset, index) in c.indices.enumerated() {
|
||||
@@ -248,7 +252,7 @@ func validateIndexTraversals<C>(
|
||||
"Index mismatch at offset \(offset) in `indices`",
|
||||
file: file, line: line)
|
||||
}
|
||||
|
||||
|
||||
// index comparison
|
||||
for (offsetA, a) in indicesIncludingEnd.enumerated() {
|
||||
XCTAssertEqual(
|
||||
@@ -259,7 +263,7 @@ func validateIndexTraversals<C>(
|
||||
a < a,
|
||||
"Index at offset \(offsetA) is less than itself",
|
||||
file: file, line: line)
|
||||
|
||||
|
||||
for (offsetB, b) in indicesIncludingEnd[..<offsetA].enumerated() {
|
||||
XCTAssertNotEqual(
|
||||
a, b,
|
||||
@@ -273,12 +277,12 @@ func validateIndexTraversals<C>(
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// `index(_:offsetBy:)` and `distance(from:to:)`
|
||||
for (startOffset, start) in indicesIncludingEnd.enumerated() {
|
||||
for (endOffset, end) in indicesIncludingEnd.enumerated() {
|
||||
let distance = endOffset - startOffset
|
||||
|
||||
|
||||
XCTAssertEqual(
|
||||
c.index(start, offsetBy: distance), end,
|
||||
"""
|
||||
@@ -295,7 +299,7 @@ func validateIndexTraversals<C>(
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// `index(_:offsetBy:limitedBy:)`
|
||||
for (startOffset, start) in indicesIncludingEnd.enumerated() {
|
||||
for (limitOffset, limit) in indicesIncludingEnd.enumerated() {
|
||||
@@ -307,7 +311,7 @@ func validateIndexTraversals<C>(
|
||||
for targetOffset in range {
|
||||
let distance = targetOffset - startOffset
|
||||
let end = c.index(start, offsetBy: distance, limitedBy: limit)
|
||||
|
||||
|
||||
if pastLimit {
|
||||
XCTAssertNil(
|
||||
end,
|
||||
@@ -328,7 +332,7 @@ func validateIndexTraversals<C>(
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// forward offsets
|
||||
if limit >= start {
|
||||
// the limit has an effect
|
||||
@@ -338,7 +342,7 @@ func validateIndexTraversals<C>(
|
||||
// the limit has no effect
|
||||
checkTargetRange(startOffset...count, pastLimit: false)
|
||||
}
|
||||
|
||||
|
||||
// backward offsets
|
||||
if limit <= start {
|
||||
// the limit has an effect
|
||||
|
||||
@@ -9,12 +9,12 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class UniquePermutationsTests: XCTestCase {
|
||||
static let numbers = [1, 1, 1, 2, 3]
|
||||
|
||||
|
||||
static let numbersPermutations: [[[Int]]] = [
|
||||
// k = 0
|
||||
[[]],
|
||||
@@ -23,26 +23,32 @@ final class UniquePermutationsTests: XCTestCase {
|
||||
// 2
|
||||
[[1, 1], [1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]],
|
||||
// 3
|
||||
[[1, 1, 1], [1, 1, 2], [1, 1, 3],
|
||||
[1, 2, 1], [1, 2, 3], [1, 3, 1], [1, 3, 2],
|
||||
[2, 1, 1], [2, 1, 3], [2, 3, 1],
|
||||
[3, 1, 1], [3, 1, 2], [3, 2, 1]],
|
||||
[
|
||||
[1, 1, 1], [1, 1, 2], [1, 1, 3],
|
||||
[1, 2, 1], [1, 2, 3], [1, 3, 1], [1, 3, 2],
|
||||
[2, 1, 1], [2, 1, 3], [2, 3, 1],
|
||||
[3, 1, 1], [3, 1, 2], [3, 2, 1],
|
||||
],
|
||||
// 4
|
||||
[[1, 1, 1, 2], [1, 1, 1, 3],
|
||||
[1, 1, 2, 1], [1, 1, 2, 3],
|
||||
[1, 1, 3, 1], [1, 1, 3, 2],
|
||||
[1, 2, 1, 1], [1, 2, 1, 3], [1, 2, 3, 1],
|
||||
[1, 3, 1, 1], [1, 3, 1, 2], [1, 3, 2, 1],
|
||||
[2, 1, 1, 1], [2, 1, 1, 3], [2, 1, 3, 1], [2, 3, 1, 1],
|
||||
[3, 1, 1, 1], [3, 1, 1, 2], [3, 1, 2, 1], [3, 2, 1, 1]],
|
||||
[
|
||||
[1, 1, 1, 2], [1, 1, 1, 3],
|
||||
[1, 1, 2, 1], [1, 1, 2, 3],
|
||||
[1, 1, 3, 1], [1, 1, 3, 2],
|
||||
[1, 2, 1, 1], [1, 2, 1, 3], [1, 2, 3, 1],
|
||||
[1, 3, 1, 1], [1, 3, 1, 2], [1, 3, 2, 1],
|
||||
[2, 1, 1, 1], [2, 1, 1, 3], [2, 1, 3, 1], [2, 3, 1, 1],
|
||||
[3, 1, 1, 1], [3, 1, 1, 2], [3, 1, 2, 1], [3, 2, 1, 1],
|
||||
],
|
||||
// 5
|
||||
[[1, 1, 1, 2, 3], [1, 1, 1, 3, 2],
|
||||
[1, 1, 2, 1, 3], [1, 1, 2, 3, 1],
|
||||
[1, 1, 3, 1, 2], [1, 1, 3, 2, 1],
|
||||
[1, 2, 1, 1, 3], [1, 2, 1, 3, 1], [1, 2, 3, 1, 1],
|
||||
[1, 3, 1, 1, 2], [1, 3, 1, 2, 1], [1, 3, 2, 1, 1],
|
||||
[2, 1, 1, 1, 3], [2, 1, 1, 3, 1], [2, 1, 3, 1, 1], [2, 3, 1, 1, 1],
|
||||
[3, 1, 1, 1, 2], [3, 1, 1, 2, 1], [3, 1, 2, 1, 1], [3, 2, 1, 1, 1]]
|
||||
[
|
||||
[1, 1, 1, 2, 3], [1, 1, 1, 3, 2],
|
||||
[1, 1, 2, 1, 3], [1, 1, 2, 3, 1],
|
||||
[1, 1, 3, 1, 2], [1, 1, 3, 2, 1],
|
||||
[1, 2, 1, 1, 3], [1, 2, 1, 3, 1], [1, 2, 3, 1, 1],
|
||||
[1, 3, 1, 1, 2], [1, 3, 1, 2, 1], [1, 3, 2, 1, 1],
|
||||
[2, 1, 1, 1, 3], [2, 1, 1, 3, 1], [2, 1, 3, 1, 1], [2, 3, 1, 1, 1],
|
||||
[3, 1, 1, 1, 2], [3, 1, 1, 2, 1], [3, 1, 2, 1, 1], [3, 2, 1, 1, 1],
|
||||
],
|
||||
]
|
||||
}
|
||||
|
||||
@@ -54,26 +60,26 @@ extension UniquePermutationsTests {
|
||||
XCTAssertEqualSequences(
|
||||
([] as [Int]).uniquePermutations(ofCount: 1...3), [])
|
||||
}
|
||||
|
||||
|
||||
func testSingleCounts() {
|
||||
for (k, expectation) in Self.numbersPermutations.enumerated() {
|
||||
XCTAssertEqualSequences(
|
||||
expectation,
|
||||
Self.numbers.uniquePermutations(ofCount: k))
|
||||
}
|
||||
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
Self.numbersPermutations[5],
|
||||
Self.numbers.uniquePermutations())
|
||||
}
|
||||
|
||||
|
||||
func testRanges() {
|
||||
for lower in Self.numbersPermutations.indices {
|
||||
// upper bounded
|
||||
XCTAssertEqualSequences(
|
||||
Self.numbersPermutations[...lower].joined(),
|
||||
Self.numbers.uniquePermutations(ofCount: ...lower))
|
||||
|
||||
|
||||
// lower bounded
|
||||
XCTAssertEqualSequences(
|
||||
Self.numbersPermutations[lower...].joined(),
|
||||
@@ -91,11 +97,11 @@ extension UniquePermutationsTests {
|
||||
extension UniquePermutationsTests {
|
||||
private final class IntBox: Hashable {
|
||||
var value: Int
|
||||
|
||||
|
||||
init(_ value: Int) {
|
||||
self.value = value
|
||||
}
|
||||
|
||||
|
||||
static func == (lhs: IntBox, rhs: IntBox) -> Bool {
|
||||
lhs.value == rhs.value
|
||||
}
|
||||
@@ -115,7 +121,7 @@ extension UniquePermutationsTests {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testLaziness() {
|
||||
XCTAssertLazySequence("ABCD".lazy.uniquePermutations())
|
||||
}
|
||||
|
||||
@@ -9,8 +9,8 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class UniqueTests: XCTestCase {
|
||||
func testUnique() {
|
||||
@@ -18,26 +18,26 @@ final class UniqueTests: XCTestCase {
|
||||
let b = a.uniqued()
|
||||
XCTAssertEqual(b.sorted(), Set(a).sorted())
|
||||
XCTAssertEqual(10, Array(b).count)
|
||||
|
||||
|
||||
let c: [Int] = []
|
||||
XCTAssertEqualSequences(c.uniqued(), [])
|
||||
|
||||
|
||||
let d = Array(repeating: 1, count: 10)
|
||||
XCTAssertEqualSequences(d.uniqued(), [1])
|
||||
}
|
||||
|
||||
|
||||
func testUniqueOn() {
|
||||
let a = ["Albemarle", "Abeforth", "Astrology", "Brandywine", "Beatrice", "Axiom"]
|
||||
let b = a.uniqued(on: { $0.first })
|
||||
XCTAssertEqual(["Albemarle", "Brandywine"], b)
|
||||
|
||||
|
||||
let c: [Int] = []
|
||||
XCTAssertEqual(c.uniqued(on: { $0.bitWidth }), [])
|
||||
|
||||
|
||||
let d = Array(repeating: "Andromeda", count: 10)
|
||||
XCTAssertEqualSequences(d.uniqued(on: { $0.first }), ["Andromeda"])
|
||||
}
|
||||
|
||||
|
||||
func testLazyUniqueOn() {
|
||||
let a = ["Albemarle", "Abeforth", "Astrology", "Brandywine", "Beatrice", "Axiom"]
|
||||
let b = a.lazy.uniqued(on: { $0.first })
|
||||
@@ -46,7 +46,7 @@ final class UniqueTests: XCTestCase {
|
||||
|
||||
let c: [Int] = []
|
||||
XCTAssertEqualSequences(c.lazy.uniqued(on: { $0.bitWidth }), [])
|
||||
|
||||
|
||||
let d = Array(repeating: "Andromeda", count: 10)
|
||||
XCTAssertEqualSequences(d.lazy.uniqued(on: { $0.first }), ["Andromeda"])
|
||||
}
|
||||
|
||||
@@ -10,10 +10,11 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
|
||||
@testable import Algorithms
|
||||
|
||||
final class windowsTests: XCTestCase {
|
||||
|
||||
|
||||
func testWindowsOfString() {
|
||||
let s = "swift"
|
||||
let w = s.windows(ofCount: 2)
|
||||
@@ -27,56 +28,56 @@ final class windowsTests: XCTestCase {
|
||||
w.formIndex(after: &i)
|
||||
XCTAssertEqualSequences(w[i], "ft")
|
||||
|
||||
// w.index(after: w.endIndex) // ← Precondition failed: windows index is out of range
|
||||
// w.index(before: w.startIndex) // ← Precondition failed: windows index is out of range
|
||||
// w.formIndex(after: &i); w[i] // ← Precondition failed: windows index is out of range
|
||||
// w.index(after: w.endIndex) // ← Precondition failed: windows index is out of range
|
||||
// w.index(before: w.startIndex) // ← Precondition failed: windows index is out of range
|
||||
// w.formIndex(after: &i); w[i] // ← Precondition failed: windows index is out of range
|
||||
}
|
||||
|
||||
|
||||
func testWindowsOfRange() {
|
||||
let a = 0...100
|
||||
|
||||
|
||||
XCTAssertTrue(a.windows(ofCount: 200).isEmpty)
|
||||
|
||||
|
||||
let w = a.windows(ofCount: 10)
|
||||
|
||||
|
||||
XCTAssertEqualSequences(w.first!, 0..<10)
|
||||
XCTAssertEqualSequences(w.last!, 91..<101)
|
||||
}
|
||||
|
||||
|
||||
func testWindowsOfInt() {
|
||||
let a = [ 0, 1, 0, 1 ].windows(ofCount: 2)
|
||||
|
||||
let a = [0, 1, 0, 1].windows(ofCount: 2)
|
||||
|
||||
XCTAssertEqual(a.count, 3)
|
||||
XCTAssertEqual(a.map { $0.reduce(0, +) }, [1, 1, 1])
|
||||
|
||||
|
||||
let a2 = [0, 1, 2, 3, 4, 5, 6].windows(ofCount: 3).map {
|
||||
$0.reduce(0, +)
|
||||
}.reduce(0, +)
|
||||
|
||||
|
||||
XCTAssertEqual(a2, 3 + 6 + 9 + 12 + 15)
|
||||
}
|
||||
|
||||
|
||||
func testWindowsCount() {
|
||||
let a = [0, 1, 2, 3, 4, 5]
|
||||
XCTAssertEqual(a.windows(ofCount: 3).count, 4)
|
||||
|
||||
|
||||
let a2 = [0, 1, 2, 3, 4]
|
||||
XCTAssertEqual(a2.windows(ofCount: 6).count, 0)
|
||||
|
||||
|
||||
let a3 = [Int]()
|
||||
XCTAssertEqual(a3.windows(ofCount: 2).count, 0)
|
||||
}
|
||||
|
||||
|
||||
func testWindowsSecondAndLast() {
|
||||
let a = [0, 1, 2, 3, 4, 5]
|
||||
let w = a.windows(ofCount: 4)
|
||||
let snd = w[w.index(after: w.startIndex)]
|
||||
XCTAssertEqualSequences(snd, [1, 2, 3, 4])
|
||||
|
||||
|
||||
let w2 = a.windows(ofCount: 3)
|
||||
XCTAssertEqualSequences(w2.last!, [3, 4, 5])
|
||||
}
|
||||
|
||||
|
||||
func testWindowsIndexAfterAndBefore() {
|
||||
let a = [0, 1, 2, 3, 4, 5].windows(ofCount: 2)
|
||||
var i = a.startIndex
|
||||
@@ -85,7 +86,7 @@ final class windowsTests: XCTestCase {
|
||||
a.formIndex(before: &i)
|
||||
XCTAssertEqualSequences(a[i], [1, 2])
|
||||
}
|
||||
|
||||
|
||||
func testWindowsIndexTraversals() {
|
||||
validateIndexTraversals(
|
||||
"".windows(ofCount: 1),
|
||||
|
||||
Reference in new issue
Block a user