mirror of
https://github.com/apple/swift-algorithms
synced 2026-11-22 04:10:39 +00:00
Compare commits
16
Commits
nate/pdqsort
..
main
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
8fdd7fe21d | ||
|
|
8d14c58467 | ||
|
|
5b7143f8e2 | ||
|
|
ea82f0e36e | ||
|
|
ff223da637 | ||
|
|
9a7f462e2e | ||
|
|
0b4376902c | ||
|
|
0aa3733a77 | ||
|
|
f6ce64a70a | ||
|
|
0e939e7bb9 | ||
|
|
66ae806bbe | ||
|
|
f970eb6c62 | ||
|
|
d019041daf | ||
|
|
401145b7b8 | ||
|
|
cdc909b93d | ||
|
|
acb4100b54 |
No files matched your search
@@ -0,0 +1,34 @@
|
||||
name: Pull request
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
types: [opened, reopened, synchronize]
|
||||
|
||||
jobs:
|
||||
validate_format_config:
|
||||
name: Validate Format Config
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout repo
|
||||
uses: actions/checkout@v4
|
||||
- name: Install apt dependencies
|
||||
run: sudo apt-get -qq update && sudo apt-get -qq -y install curl
|
||||
- name: Compare against swift-mmio swift-format config
|
||||
run: |
|
||||
curl -sL https://raw.githubusercontent.com/apple/swift-mmio/refs/heads/main/.swift-format -o .swift-format-mmio
|
||||
diff .swift-format .swift-format-mmio
|
||||
|
||||
tests:
|
||||
name: Test
|
||||
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@main
|
||||
with:
|
||||
enable_wasm_sdk_build: true
|
||||
enable_android_sdk_build: true
|
||||
enable_android_sdk_checks: true
|
||||
|
||||
soundness:
|
||||
name: Soundness
|
||||
uses: swiftlang/github-workflows/.github/workflows/soundness.yml@main
|
||||
@@ -0,0 +1,10 @@
|
||||
@@===----------------------------------------------------------------------===@@
|
||||
@@
|
||||
@@ This source file is part of the Swift Algorithms open source project
|
||||
@@
|
||||
@@ Copyright (c) YEARS Apple Inc. and the Swift project authors
|
||||
@@ Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
@@
|
||||
@@ See https://swift.org/LICENSE.txt for license information
|
||||
@@
|
||||
@@===----------------------------------------------------------------------===@@
|
||||
@@ -0,0 +1,30 @@
|
||||
.gitignore
|
||||
**/.gitignore
|
||||
.licenseignore
|
||||
.gitattributes
|
||||
.git-blame-ignore-revs
|
||||
.mailfilter
|
||||
.mailmap
|
||||
.spi.yml
|
||||
.swift-format
|
||||
.editorconfig
|
||||
.github/*
|
||||
*.md
|
||||
*.mdoc
|
||||
*.txt
|
||||
*.yml
|
||||
*.yaml
|
||||
*.json
|
||||
*.png
|
||||
*.bash
|
||||
*.cmake
|
||||
*.cmake.in
|
||||
Package.swift
|
||||
**/Package.swift
|
||||
Package@*.swift
|
||||
**/Package@*.swift
|
||||
Package.resolved
|
||||
**/Package.resolved
|
||||
.unacceptablelanguageignore
|
||||
**/Snapshots/*
|
||||
Xcode/*
|
||||
@@ -2,4 +2,3 @@ version: 1
|
||||
builder:
|
||||
configs:
|
||||
- documentation_targets: [Algorithms]
|
||||
|
||||
@@ -0,0 +1,71 @@
|
||||
{
|
||||
"fileScopedDeclarationPrivacy" : {
|
||||
"accessLevel" : "private"
|
||||
},
|
||||
"indentation" : {
|
||||
"spaces" : 2
|
||||
},
|
||||
"indentConditionalCompilationBlocks" : false,
|
||||
"indentSwitchCaseLabels" : false,
|
||||
"lineBreakAroundMultilineExpressionChainComponents" : false,
|
||||
"lineBreakBeforeControlFlowKeywords" : false,
|
||||
"lineBreakBeforeEachArgument" : false,
|
||||
"lineBreakBeforeEachGenericRequirement" : false,
|
||||
"lineLength" : 80,
|
||||
"maximumBlankLines" : 1,
|
||||
"multiElementCollectionTrailingCommas" : true,
|
||||
"noAssignmentInExpressions" : {
|
||||
"allowedFunctions" : [
|
||||
"XCTAssertNoThrow"
|
||||
]
|
||||
},
|
||||
"prioritizeKeepingFunctionOutputTogether" : false,
|
||||
"respectsExistingLineBreaks" : true,
|
||||
"rules" : {
|
||||
"AllPublicDeclarationsHaveDocumentation" : false,
|
||||
"AlwaysUseLiteralForEmptyCollectionInit" : true,
|
||||
"AlwaysUseLowerCamelCase" : true,
|
||||
"AmbiguousTrailingClosureOverload" : false,
|
||||
"BeginDocumentationCommentWithOneLineSummary" : true,
|
||||
"DoNotUseSemicolons" : true,
|
||||
"DontRepeatTypeInStaticProperties" : true,
|
||||
"FileScopedDeclarationPrivacy" : true,
|
||||
"FullyIndirectEnum" : true,
|
||||
"GroupNumericLiterals" : true,
|
||||
"IdentifiersMustBeASCII" : true,
|
||||
"NeverForceUnwrap" : true,
|
||||
"NeverUseForceTry" : true,
|
||||
"NeverUseImplicitlyUnwrappedOptionals" : true,
|
||||
"NoAccessLevelOnExtensionDeclaration" : true,
|
||||
"NoAssignmentInExpressions" : true,
|
||||
"NoBlockComments" : true,
|
||||
"NoCasesWithOnlyFallthrough" : true,
|
||||
"NoEmptyTrailingClosureParentheses" : true,
|
||||
"NoLabelsInCasePatterns" : true,
|
||||
"NoLeadingUnderscores" : false,
|
||||
"NoParensAroundConditions" : true,
|
||||
"NoPlaygroundLiterals" : true,
|
||||
"NoVoidReturnOnFunctionSignature" : true,
|
||||
"OmitExplicitReturns" : true,
|
||||
"OneCasePerLine" : true,
|
||||
"OneVariableDeclarationPerLine" : true,
|
||||
"OnlyOneTrailingClosureArgument" : true,
|
||||
"OrderedImports" : true,
|
||||
"ReplaceForEachWithForLoop" : true,
|
||||
"ReturnVoidInsteadOfEmptyTuple" : true,
|
||||
"TypeNamesShouldBeCapitalized" : true,
|
||||
"UseEarlyExits" : false,
|
||||
"UseExplicitNilCheckInConditions" : true,
|
||||
"UseLetInEveryBoundCaseVariable" : true,
|
||||
"UseShorthandTypeNames" : true,
|
||||
"UseSingleLinePropertyGetter" : true,
|
||||
"UseSynthesizedInitializer" : true,
|
||||
"UseTripleSlashForDocumentationComments" : true,
|
||||
"UseWhereClausesInForLoops" : false,
|
||||
"ValidateDocumentationComments" : true
|
||||
},
|
||||
"spacesBeforeEndOfLineComments": 2,
|
||||
"spacesAroundRangeFormationOperators" : false,
|
||||
"tabWidth" : 2,
|
||||
"version" : 1
|
||||
}
|
||||
+42
-4
@@ -8,7 +8,26 @@ This project follows semantic versioning.
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
*No new changes.*
|
||||
### Additions
|
||||
|
||||
- Bidirectional collections have a new `ends(with:)` method that matches
|
||||
the behavior of the standard library's `starts(with:)` method. ([#224])
|
||||
|
||||
<!-- *No new changes.* -->
|
||||
|
||||
## [1.2.1] - 2025-02-10
|
||||
|
||||
### Changes
|
||||
|
||||
- The package now has a minimum Swift version of Swift 5.7. ([#240])
|
||||
- Adds a project for building with Xcode. ([#246])
|
||||
|
||||
### Fixes
|
||||
|
||||
- Fix for Swift 6 language mode errors. ([#230])
|
||||
- Minor improvements to documentation and performance. ([#220], [#222], [#223], [#225], [#227], [#228])
|
||||
|
||||
The 1.2.1 release includes contributions from [b1ackturtle], [CheATSlark], [dabrahams], [glessard], [j-f1], [marcosgriselli], [mrs1669], [natecook1000], [rex4539], and [schlagelk]. Thank you!
|
||||
|
||||
## [1.2.0] - 2023-11-14
|
||||
|
||||
@@ -222,7 +241,7 @@ The 0.2.0 release includes contributions from [CTMacUser], [LemonSpike],
|
||||
- The base collections of the sequence and collection wrapper types are no
|
||||
longer public ([#85], [#125]), and the wrapper types no longer conform to the
|
||||
`Equatable` or `Hashable` protocols ([#124]). If you need those conformances,
|
||||
convert the wrapper type to an `Array` or other collection currrency type
|
||||
convert the wrapper type to an `Array` or other collection currency type
|
||||
before storing. Please file an issue if these changes pose a problem for your
|
||||
use case.
|
||||
|
||||
@@ -316,7 +335,7 @@ The 0.0.3 release includes contributions from [benrimmington], [danielctull],
|
||||
### Fixes
|
||||
|
||||
- `Algorithms` now builds under SwiftPM on Windows.
|
||||
- A wide variety of errors, misspellings, and ommissions in the documentation
|
||||
- A wide variety of errors, misspellings, and omissions in the documentation
|
||||
and guides have been fixed.
|
||||
- Index/distance calculations for the `Product2` and `Chain` types have been
|
||||
corrected.
|
||||
@@ -338,7 +357,8 @@ This changelog's format is based on [Keep a Changelog](https://keepachangelog.co
|
||||
|
||||
<!-- Link references for releases -->
|
||||
|
||||
[Unreleased]: https://github.com/apple/swift-algorithms/compare/1.2.0...HEAD
|
||||
[Unreleased]: https://github.com/apple/swift-algorithms/compare/1.2.1...HEAD
|
||||
[1.2.0]: https://github.com/apple/swift-algorithms/compare/1.2.0...1.2.1
|
||||
[1.2.0]: https://github.com/apple/swift-algorithms/compare/1.1.0...1.2.0
|
||||
[1.1.0]: https://github.com/apple/swift-algorithms/compare/1.0.0...1.1.0
|
||||
[1.0.0]: https://github.com/apple/swift-algorithms/compare/0.2.1...1.0.0
|
||||
@@ -385,33 +405,50 @@ This changelog's format is based on [Keep a Changelog](https://keepachangelog.co
|
||||
[#202]: https://github.com/apple/swift-algorithms/pull/202
|
||||
[#210]: https://github.com/apple/swift-algorithms/pull/210
|
||||
[#211]: https://github.com/apple/swift-algorithms/pull/211
|
||||
[#224]: https://github.com/apple/swift-algorithms/pull/224
|
||||
[#220]: https://github.com/apple/swift-algorithms/pull/220
|
||||
[#222]: https://github.com/apple/swift-algorithms/pull/222
|
||||
[#223]: https://github.com/apple/swift-algorithms/pull/223
|
||||
[#225]: https://github.com/apple/swift-algorithms/pull/225
|
||||
[#227]: https://github.com/apple/swift-algorithms/pull/227
|
||||
[#228]: https://github.com/apple/swift-algorithms/pull/228
|
||||
[#230]: https://github.com/apple/swift-algorithms/pull/230
|
||||
[#240]: https://github.com/apple/swift-algorithms/pull/240
|
||||
[#246]: https://github.com/apple/swift-algorithms/pull/246
|
||||
|
||||
<!-- Link references for contributors -->
|
||||
|
||||
[amomchilov]: https://github.com/apple/swift-algorithms/commits?author=amomchilov
|
||||
[AustinConlon]: https://github.com/apple/swift-algorithms/commits?author=AustinConlon
|
||||
[b1ackturtle]: https://github.com/apple/swift-algorithms/commits?author=b1ackturtle
|
||||
[benrimmington]: https://github.com/apple/swift-algorithms/commits?author=benrimmington
|
||||
[bjhomer]: https://github.com/apple/swift-algorithms/commits?author=bjhomer
|
||||
[CheATSlark]: https://github.com/apple/swift-algorithms/commits?author=CheATSlark
|
||||
[CTMacUser]: https://github.com/apple/swift-algorithms/commits?author=CTMacUser
|
||||
[dabrahams]: https://github.com/apple/swift-algorithms/commits?author=dabrahams
|
||||
[danielctull]: https://github.com/apple/swift-algorithms/commits?author=danielctull
|
||||
[dhruvshah8]: https://github.com/apple/swift-algorithms/commits?author=dhruvshah8
|
||||
[dickoff]: https://github.com/apple/swift-algorithms/commits?author=dickoff
|
||||
[egorzhdan]: https://github.com/apple/swift-algorithms/commits?author=egorzhdan
|
||||
[fedeci]: https://github.com/apple/swift-algorithms/commits?author=fedeci
|
||||
[glessard]: https://github.com/apple/swift-algorithms/commits?author=glessard
|
||||
[gwynne]: https://github.com/apple/swift-algorithms/commits?author=gwynne
|
||||
[hashemi]: https://github.com/apple/swift-algorithms/commits?author=hashemi
|
||||
[iainsmith]: https://github.com/apple/swift-algorithms/commits?author=iainsmith
|
||||
[IanKeen]: https://github.com/apple/swift-algorithms/commits?author=IanKeen
|
||||
[iSame7]: https://github.com/apple/swift-algorithms/commits?author=iSame7
|
||||
[j-f1]: https://github.com/apple/swift-algorithms/commits?author=j-f1
|
||||
[karwa]: https://github.com/apple/swift-algorithms/commits?author=karwa
|
||||
[kylemacomber]: https://github.com/apple/swift-algorithms/commits?author=kylemacomber
|
||||
[LemonSpike]: https://github.com/apple/swift-algorithms/commits?author=LemonSpike
|
||||
[LucianoPAlmeida]: https://github.com/apple/swift-algorithms/commits?author=LucianoPAlmeida
|
||||
[marcosgriselli]: https://github.com/apple/swift-algorithms/commits?author=marcosgriselli
|
||||
[markuswntr]: https://github.com/apple/swift-algorithms/commits?author=markuswntr
|
||||
[mattyoung]: https://github.com/apple/swift-algorithms/commits?author=mattyoung
|
||||
[mdznr]: https://github.com/apple/swift-algorithms/commits?author=mdznr
|
||||
[michiboo]: https://github.com/apple/swift-algorithms/commits?author=michiboo
|
||||
[mpangburn]: https://github.com/apple/swift-algorithms/commits?author=mpangburn
|
||||
[mrs1669]: https://github.com/apple/swift-algorithms/commits?author=mrs1669
|
||||
[natecook1000]: https://github.com/apple/swift-algorithms/commits?author=natecook1000
|
||||
[nordicio]: https://github.com/apple/swift-algorithms/commits?author=nordicio
|
||||
[ole]: https://github.com/apple/swift-algorithms/commits?author=ole
|
||||
@@ -419,6 +456,7 @@ This changelog's format is based on [Keep a Changelog](https://keepachangelog.co
|
||||
[pmtao]: https://github.com/apple/swift-algorithms/commits?author=pmtao
|
||||
[Qata]: https://github.com/apple/swift-algorithms/commits?author=Qata
|
||||
[rakaramos]: https://github.com/apple/swift-algorithms/commits?author=rakaramos
|
||||
[rex4539]: https://github.com/apple/swift-algorithms/commits?author=rex4539
|
||||
[rockbruno]: https://github.com/apple/swift-algorithms/commits?author=rockbruno
|
||||
[Roshankumar350]: https://github.com/apple/swift-algorithms/commits?author=Roshankumar350
|
||||
[schlagelk]: https://github.com/apple/swift-algorithms/commits?author=schlagelk
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
# EndsWith
|
||||
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/EndsWith.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/EndsWithTests.swift)]
|
||||
|
||||
This function checks whether the final elements of the one collection are the same as the elements in another collection.
|
||||
```
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The `ends(with:)` and `ends(with:by:)` functions are added as methods on an extension of
|
||||
`BidirectionalCollection`.
|
||||
|
||||
```swift
|
||||
extension BidirectionalCollection {
|
||||
public func ends<PossibleSuffix: BidirectionalCollection>(
|
||||
with possibleSuffix: PossibleSuffix
|
||||
) -> Bool where PossibleSuffix.Element == Element
|
||||
|
||||
public func ends<PossibleSuffix: BidirectionalCollection>(
|
||||
with possibleSuffix: PossibleSuffix,
|
||||
by areEquivalent: (Element, PossibleSuffix.Element) throws -> Bool
|
||||
) rethrows -> Bool
|
||||
}
|
||||
```
|
||||
|
||||
This method requires `BidirectionalCollection` for being able to traverse back from the end of the collection. It also requires the `possibleSuffix` to be `BidirectionalCollection`, because it too needs to be traverse backwards, to compare its elements against `self` from back to front.
|
||||
|
||||
### Complexity
|
||||
|
||||
O(*m*), where *m* is the lesser of the length of the collection and the length of `possibleSuffix`.
|
||||
|
||||
### Naming
|
||||
|
||||
The function's name resembles that of an existing Swift function
|
||||
`starts(with:)`, which performs same operation however in the forward direction
|
||||
of the collection.
|
||||
+19
-24
@@ -13,28 +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.git", from: "1.0.0"),
|
||||
],
|
||||
targets: [
|
||||
.target(
|
||||
name: "Algorithms",
|
||||
dependencies: [
|
||||
.product(name: "RealModule", package: "swift-numerics"),
|
||||
],
|
||||
swiftSettings: [
|
||||
.define("INSERTION_TEMP"),
|
||||
// .define("INSERTION_MAX_32"),
|
||||
]
|
||||
),
|
||||
.testTarget(
|
||||
name: "SwiftAlgorithmsTests",
|
||||
dependencies: ["Algorithms"]),
|
||||
]
|
||||
name: "swift-algorithms",
|
||||
products: [
|
||||
.library(
|
||||
name: "Algorithms",
|
||||
targets: ["Algorithms"])
|
||||
],
|
||||
dependencies: [
|
||||
.package(url: "https://github.com/apple/swift-numerics.git", from: "1.0.0")
|
||||
],
|
||||
targets: [
|
||||
.target(
|
||||
name: "Algorithms",
|
||||
dependencies: [
|
||||
.product(name: "RealModule", package: "swift-numerics")
|
||||
]),
|
||||
.testTarget(
|
||||
name: "SwiftAlgorithmsTests",
|
||||
dependencies: ["Algorithms"]),
|
||||
]
|
||||
)
|
||||
Executable
+20
@@ -0,0 +1,20 @@
|
||||
#!/bin/bash
|
||||
##===----------------------------------------------------------------------===##
|
||||
##
|
||||
## This source file is part of the Swift Algorithms open source project
|
||||
##
|
||||
## Copyright (c) 2025 Apple Inc. and the Swift project authors
|
||||
## Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
##
|
||||
## See https://swift.org/LICENSE.txt for license information
|
||||
##
|
||||
##===----------------------------------------------------------------------===##
|
||||
|
||||
# Move to the project root
|
||||
cd "$(dirname "$0")" || exit
|
||||
cd ..
|
||||
echo "Formatting Swift sources in $(pwd)"
|
||||
|
||||
# Run the format / lint commands
|
||||
git ls-files -z '*.swift' | xargs -0 swift format format --parallel --in-place
|
||||
git ls-files -z '*.swift' | xargs -0 swift format lint --strict --parallel
|
||||
@@ -126,7 +126,7 @@ extension AdjacentPairsSequence: Sequence {
|
||||
}
|
||||
|
||||
extension AdjacentPairsSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
/// A collection of adjacent pairs of elements built from an underlying
|
||||
/// collection.
|
||||
@@ -143,7 +143,8 @@ public struct AdjacentPairsCollection<Base: Collection> {
|
||||
@inlinable
|
||||
internal init(base: Base) {
|
||||
self.base = base
|
||||
self.secondBaseIndex = base.isEmpty
|
||||
self.secondBaseIndex =
|
||||
base.isEmpty
|
||||
? base.endIndex
|
||||
: base.index(after: base.startIndex)
|
||||
}
|
||||
@@ -154,7 +155,7 @@ extension AdjacentPairsCollection {
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal var first: Base.Index
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var second: Base.Index
|
||||
|
||||
@@ -168,7 +169,7 @@ extension AdjacentPairsCollection {
|
||||
public static func == (lhs: Index, rhs: Index) -> Bool {
|
||||
lhs.first == rhs.first
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Index, rhs: Index) -> Bool {
|
||||
lhs.first < rhs.first
|
||||
@@ -183,7 +184,7 @@ extension AdjacentPairsCollection: Collection {
|
||||
first: secondBaseIndex == base.endIndex ? base.endIndex : base.startIndex,
|
||||
second: secondBaseIndex)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(first: base.endIndex, second: base.endIndex)
|
||||
@@ -207,20 +208,23 @@ extension AdjacentPairsCollection: Collection {
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
guard distance != 0 else { return i }
|
||||
|
||||
guard let result = distance > 0
|
||||
? offsetForward(i, by: distance, limitedBy: endIndex)
|
||||
: offsetBackward(i, by: -distance, limitedBy: startIndex)
|
||||
guard
|
||||
let result = distance > 0
|
||||
? offsetForward(i, by: distance, limitedBy: endIndex)
|
||||
: offsetBackward(i, by: -distance, limitedBy: startIndex)
|
||||
else { fatalError("Index out of bounds") }
|
||||
return result
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ i: Index, offsetBy distance: Int, limitedBy limit: Index
|
||||
_ i: Index,
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
guard distance != 0 else { return i }
|
||||
guard limit != i else { return nil }
|
||||
|
||||
|
||||
if distance > 0 {
|
||||
let limit = limit > i ? limit : endIndex
|
||||
return offsetForward(i, by: distance, limitedBy: limit)
|
||||
@@ -229,38 +233,48 @@ extension AdjacentPairsCollection: Collection {
|
||||
return offsetBackward(i, by: -distance, limitedBy: limit)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
_ i: Index,
|
||||
by distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
assert(limit > i)
|
||||
|
||||
guard let newFirst = base.index(i.second, offsetBy: distance - 1, limitedBy: limit.first),
|
||||
newFirst != base.endIndex
|
||||
|
||||
let newFirst = base.index(
|
||||
i.second,
|
||||
offsetBy: distance - 1,
|
||||
limitedBy: limit.first)
|
||||
guard let newFirst, newFirst != base.endIndex
|
||||
else { return nil }
|
||||
|
||||
let newSecond = base.index(after: newFirst)
|
||||
|
||||
|
||||
precondition(newSecond <= base.endIndex, "Can't advance beyond endIndex")
|
||||
return newSecond == base.endIndex
|
||||
? endIndex
|
||||
: Index(first: newFirst, second: newSecond)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
_ i: Index,
|
||||
by distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
assert(limit < i)
|
||||
|
||||
|
||||
let offset = i == endIndex ? 0 : 1
|
||||
guard let newSecond = base.index(
|
||||
let newSecond = base.index(
|
||||
i.first,
|
||||
offsetBy: -(distance - offset),
|
||||
limitedBy: limit.second)
|
||||
guard let newSecond
|
||||
else { return nil }
|
||||
|
||||
let newFirst = base.index(newSecond, offsetBy: -1)
|
||||
precondition(newFirst >= base.startIndex, "Can't move before startIndex")
|
||||
return Index(first: newFirst, second: newSecond)
|
||||
@@ -282,12 +296,12 @@ extension AdjacentPairsCollection: Collection {
|
||||
}
|
||||
|
||||
extension AdjacentPairsCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
where Base: BidirectionalCollection {
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i != startIndex, "Can't offset before startIndex")
|
||||
let second = i == endIndex
|
||||
let second =
|
||||
i == endIndex
|
||||
? base.index(before: base.endIndex)
|
||||
: i.first
|
||||
let first = base.index(before: second)
|
||||
@@ -296,10 +310,10 @@ extension AdjacentPairsCollection: BidirectionalCollection
|
||||
}
|
||||
|
||||
extension AdjacentPairsCollection: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension AdjacentPairsCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension AdjacentPairsCollection.Index: Hashable where Base.Index: Hashable {
|
||||
@inlinable
|
||||
|
||||
@@ -11,12 +11,11 @@
|
||||
|
||||
/// A concatenation of two sequences with the same element type.
|
||||
public struct Chain2Sequence<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,29 +32,30 @@ extension Chain2Sequence: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var iterator1: Base1.Iterator
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var iterator2: Base2.Iterator
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(_ concatenation: Chain2Sequence) {
|
||||
iterator1 = concatenation.base1.makeIterator()
|
||||
iterator2 = concatenation.base2.makeIterator()
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Base1.Element? {
|
||||
return iterator1.next() ?? iterator2.next()
|
||||
iterator1.next() ?? iterator2.next()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(self)
|
||||
}
|
||||
}
|
||||
|
||||
extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection {
|
||||
extension Chain2Sequence: Collection
|
||||
where Base1: Collection, Base2: Collection {
|
||||
/// A position in a `Chain2Sequence` instance.
|
||||
public struct Index: Comparable {
|
||||
// The internal index representation, which can either be an index of the
|
||||
@@ -91,14 +91,14 @@ extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection
|
||||
return true
|
||||
case (.second, .first):
|
||||
return false
|
||||
case let (.first(l), .first(r)):
|
||||
case (.first(let l), .first(let r)):
|
||||
return l < r
|
||||
case let (.second(l), .second(r)):
|
||||
case (.second(let l), .second(let r)):
|
||||
return l < r
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// Converts an index of `Base1` to the corresponding `Index` by mapping
|
||||
/// `base1.endIndex` to `base2.startIndex`.
|
||||
@inlinable
|
||||
@@ -121,9 +121,9 @@ extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection
|
||||
@inlinable
|
||||
public subscript(i: Index) -> Base1.Element {
|
||||
switch i.position {
|
||||
case let .first(i):
|
||||
case .first(let i):
|
||||
return base1[i]
|
||||
case let .second(i):
|
||||
case .second(let i):
|
||||
return base2[i]
|
||||
}
|
||||
}
|
||||
@@ -131,23 +131,23 @@ extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
switch i.position {
|
||||
case let .first(i):
|
||||
case .first(let i):
|
||||
assert(i != base1.endIndex)
|
||||
return normalizeIndex(base1.index(after: i))
|
||||
case let .second(i):
|
||||
case .second(let i):
|
||||
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,45 +168,50 @@ extension Chain2Sequence: 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
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
_ i: Index,
|
||||
by distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance >= 0)
|
||||
assert(limit >= i)
|
||||
|
||||
|
||||
switch (i.position, limit.position) {
|
||||
case let (.first(i), .first(limit)):
|
||||
case (.first(let i), .first(let 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`
|
||||
return normalizeIndex(j)
|
||||
} else {
|
||||
|
||||
case (.first(let i), .second(let limit)):
|
||||
guard
|
||||
let j = base1.index(i, offsetBy: distance, limitedBy: base1.endIndex)
|
||||
else {
|
||||
// the offset overflows the bounds of `base1` by `n - d`
|
||||
let d = base1.distance(from: i, to: base1.endIndex)
|
||||
return base2.index(base2.startIndex, offsetBy: distance - d, limitedBy: limit)
|
||||
return
|
||||
base2
|
||||
.index(base2.startIndex, offsetBy: distance - d, limitedBy: limit)
|
||||
.map(Index.init(second:))
|
||||
}
|
||||
|
||||
// the offset stays within the bounds of `base1`
|
||||
return normalizeIndex(j)
|
||||
|
||||
case (.second, .first):
|
||||
// impossible because `limit >= i`
|
||||
fatalError()
|
||||
|
||||
case let (.second(i), .second(limit)):
|
||||
|
||||
case (.second(let i), .second(let limit)):
|
||||
return base2.index(i, offsetBy: distance, limitedBy: limit)
|
||||
.map(Index.init(second:))
|
||||
}
|
||||
@@ -214,49 +219,54 @@ extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
_ i: Index,
|
||||
by distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance >= 0)
|
||||
assert(limit <= i)
|
||||
|
||||
|
||||
switch (i.position, limit.position) {
|
||||
case let (.first(i), .first(limit)):
|
||||
case (.first(let i), .first(let 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`
|
||||
return Index(second: j)
|
||||
} else {
|
||||
|
||||
case (.second(let i), .first(let limit)):
|
||||
guard
|
||||
let j = base2.index(i, offsetBy: -distance, limitedBy: base2.startIndex)
|
||||
else {
|
||||
// the offset overflows the bounds of `base2` by `n - d`
|
||||
let d = base2.distance(from: base2.startIndex, to: i)
|
||||
return base1.index(base1.endIndex, offsetBy: -(distance - d), limitedBy: limit)
|
||||
return
|
||||
base1
|
||||
.index(base1.endIndex, offsetBy: -(distance - d), limitedBy: limit)
|
||||
.map(Index.init(first:))
|
||||
}
|
||||
// the offset stays within the bounds of `base2`
|
||||
return Index(second: j)
|
||||
|
||||
case let (.second(i), .second(limit)):
|
||||
case (.second(let i), .second(let limit)):
|
||||
// `limit` is relevant, so `base1` cannot be reached
|
||||
return base2.index(i, offsetBy: -distance, limitedBy: limit)
|
||||
.map(Index.init(second:))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
switch (start.position, end.position) {
|
||||
case let (.first(i), .first(j)):
|
||||
case (.first(let i), .first(let j)):
|
||||
return base1.distance(from: i, to: j)
|
||||
case let (.second(i), .second(j)):
|
||||
case (.second(let i), .second(let j)):
|
||||
return base2.distance(from: i, to: j)
|
||||
case let (.first(i), .second(j)):
|
||||
case (.first(let i), .second(let j)):
|
||||
return base1.distance(from: i, to: base1.endIndex)
|
||||
+ base2.distance(from: base2.startIndex, to: j)
|
||||
case let (.second(i), .first(j)):
|
||||
case (.second(let i), .first(let j)):
|
||||
return base2.distance(from: i, to: base2.startIndex)
|
||||
+ base1.distance(from: base1.endIndex, to: j)
|
||||
}
|
||||
@@ -264,15 +274,14 @@ extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection
|
||||
}
|
||||
|
||||
extension Chain2Sequence: 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")
|
||||
switch i.position {
|
||||
case let .first(i):
|
||||
case .first(let i):
|
||||
return Index(first: base1.index(before: i))
|
||||
case let .second(i):
|
||||
case .second(let i):
|
||||
return i == base2.startIndex
|
||||
? Index(first: base1.index(before: base1.endIndex))
|
||||
: Index(second: base2.index(before: i))
|
||||
@@ -281,7 +290,7 @@ extension Chain2Sequence: BidirectionalCollection
|
||||
}
|
||||
|
||||
extension Chain2Sequence: RandomAccessCollection
|
||||
where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
|
||||
where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// chain(_:_:)
|
||||
|
||||
+195
-140
@@ -17,19 +17,19 @@ public struct ChunkedByCollection<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 end index of the first chunk.
|
||||
@usableFromInline
|
||||
internal var endOfFirstChunk: Base.Index
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base,
|
||||
@@ -40,7 +40,7 @@ public struct ChunkedByCollection<Base: Collection, Subject> {
|
||||
self.projection = projection
|
||||
self.belongInSameGroup = belongInSameGroup
|
||||
self.endOfFirstChunk = base.startIndex
|
||||
|
||||
|
||||
if !base.isEmpty {
|
||||
endOfFirstChunk = endOfChunk(startingAt: base.startIndex)
|
||||
}
|
||||
@@ -53,19 +53,19 @@ extension ChunkedByCollection: Collection {
|
||||
/// 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.
|
||||
@@ -78,24 +78,24 @@ extension ChunkedByCollection: Collection {
|
||||
@inlinable
|
||||
internal func endOfChunk(startingAt start: Base.Index) -> Base.Index {
|
||||
var subject = projection(base[start])
|
||||
|
||||
|
||||
return base[base.index(after: start)...].endOfPrefix(while: { element in
|
||||
let nextSubject = projection(element)
|
||||
defer { subject = nextSubject }
|
||||
return belongInSameGroup(subject, nextSubject)
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(base.startIndex..<endOfFirstChunk)
|
||||
}
|
||||
|
||||
|
||||
@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")
|
||||
@@ -104,7 +104,7 @@ extension ChunkedByCollection: Collection {
|
||||
let end = endOfChunk(startingAt: upperBound)
|
||||
return Index(upperBound..<end)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> Base.SubSequence {
|
||||
precondition(position != endIndex, "Can't subscript using endIndex")
|
||||
@@ -115,15 +115,14 @@ extension ChunkedByCollection: Collection {
|
||||
extension ChunkedByCollection.Index: Hashable where Base.Index: Hashable {}
|
||||
|
||||
extension ChunkedByCollection: 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)
|
||||
var subject = projection(base[indexBeforeEnd])
|
||||
|
||||
|
||||
return base[..<indexBeforeEnd].startOfSuffix(while: { element in
|
||||
let nextSubject = projection(element)
|
||||
defer { subject = nextSubject }
|
||||
@@ -148,7 +147,7 @@ extension ChunkedByCollection: LazyCollectionProtocol {}
|
||||
public struct ChunkedOnCollection<Base: Collection, Subject: Equatable> {
|
||||
@usableFromInline
|
||||
internal var chunked: ChunkedByCollection<Base, Subject>
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base,
|
||||
@@ -163,24 +162,26 @@ public struct ChunkedOnCollection<Base: Collection, Subject: Equatable> {
|
||||
|
||||
extension ChunkedOnCollection: Collection {
|
||||
public typealias Index = ChunkedByCollection<Base, Subject>.Index
|
||||
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
chunked.startIndex
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
chunked.endIndex
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> (Subject, Base.SubSequence) {
|
||||
let subsequence = chunked[position]
|
||||
// swift-format-ignore: NeverForceUnwrap
|
||||
// Chunks are never empty, so `.first!` is safe.
|
||||
let subject = chunked.projection(subsequence.first!)
|
||||
return (subject, subsequence)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
chunked.index(after: i)
|
||||
@@ -188,8 +189,7 @@ extension ChunkedOnCollection: Collection {
|
||||
}
|
||||
|
||||
extension ChunkedOnCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
where Base: BidirectionalCollection {
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
chunked.index(before: i)
|
||||
@@ -204,26 +204,26 @@ public struct EvenlyChunkedCollection<Base: Collection> {
|
||||
/// The base collection.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
/// The number of equal chunks the base collection is divided into.
|
||||
@usableFromInline
|
||||
internal let numberOfChunks: Int
|
||||
|
||||
|
||||
/// The count of the base collection.
|
||||
@usableFromInline
|
||||
internal let baseCount: Int
|
||||
|
||||
|
||||
/// The upper bound of the first chunk.
|
||||
@usableFromInline
|
||||
internal var firstUpperBound: Base.Index
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, numberOfChunks: Int) {
|
||||
self.base = base
|
||||
self.numberOfChunks = numberOfChunks
|
||||
self.baseCount = base.count
|
||||
self.firstUpperBound = base.startIndex
|
||||
|
||||
|
||||
if numberOfChunks > 0 {
|
||||
firstUpperBound = endOfChunk(startingAt: base.startIndex, offset: 0)
|
||||
}
|
||||
@@ -237,37 +237,42 @@ extension EvenlyChunkedCollection {
|
||||
internal var numberOfLargeChunks: Int {
|
||||
baseCount % numberOfChunks
|
||||
}
|
||||
|
||||
|
||||
/// Returns the size of a chunk at a given offset.
|
||||
@inlinable
|
||||
internal func sizeOfChunk(offset: Int) -> Int {
|
||||
let isLargeChunk = offset < numberOfLargeChunks
|
||||
return baseCount / numberOfChunks + (isLargeChunk ? 1 : 0)
|
||||
}
|
||||
|
||||
|
||||
/// Returns the index in the base collection of the end of the chunk starting
|
||||
/// at the given index.
|
||||
@inlinable
|
||||
internal func endOfChunk(startingAt start: Base.Index, offset: Int) -> Base.Index {
|
||||
internal func endOfChunk(startingAt start: Base.Index, offset: Int)
|
||||
-> Base.Index
|
||||
{
|
||||
base.index(start, offsetBy: sizeOfChunk(offset: offset))
|
||||
}
|
||||
|
||||
|
||||
/// 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, offset: Int) -> Base.Index {
|
||||
internal func startOfChunk(endingAt end: Base.Index, offset: Int)
|
||||
-> Base.Index
|
||||
{
|
||||
base.index(end, offsetBy: -sizeOfChunk(offset: offset))
|
||||
}
|
||||
|
||||
|
||||
/// Returns the index that corresponds to the chunk that starts at the given
|
||||
/// base index.
|
||||
@inlinable
|
||||
internal func indexOfChunk(startingAt start: Base.Index, offset: Int) -> Index {
|
||||
internal func indexOfChunk(startingAt start: Base.Index, offset: Int) -> Index
|
||||
{
|
||||
guard offset != numberOfChunks else { return endIndex }
|
||||
let end = endOfChunk(startingAt: start, offset: offset)
|
||||
return Index(start..<end, offset: offset)
|
||||
}
|
||||
|
||||
|
||||
/// Returns the index that corresponds to the chunk that ends at the given
|
||||
/// base index.
|
||||
@inlinable
|
||||
@@ -282,55 +287,56 @@ extension EvenlyChunkedCollection: Collection {
|
||||
/// The range corresponding to the chunk at this position.
|
||||
@usableFromInline
|
||||
internal var baseRange: Range<Base.Index>
|
||||
|
||||
/// The offset corresponding to the chunk at this position. The first chunk
|
||||
/// has offset `0` and all other chunks have an offset `1` greater than the
|
||||
/// previous.
|
||||
|
||||
/// The offset corresponding to the chunk at this position.
|
||||
///
|
||||
/// The first chunk has offset `0` and all other chunks have an offset
|
||||
/// `1` greater than the previous.
|
||||
@usableFromInline
|
||||
internal var offset: Int
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(_ baseRange: Range<Base.Index>, offset: Int) {
|
||||
self.baseRange = baseRange
|
||||
self.offset = offset
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.offset == rhs.offset
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.offset < rhs.offset
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public typealias Element = Base.SubSequence
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(base.startIndex..<firstUpperBound, offset: 0)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(base.endIndex..<base.endIndex, offset: numberOfChunks)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i != endIndex, "Can't advance past endIndex")
|
||||
let start = i.baseRange.upperBound
|
||||
return indexOfChunk(startingAt: start, offset: i.offset + 1)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> Element {
|
||||
precondition(position != endIndex)
|
||||
return base[position.baseRange]
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
/// Returns the base distance between two `EvenChunksCollection` indices
|
||||
@@ -338,14 +344,14 @@ extension EvenlyChunkedCollection: Collection {
|
||||
func baseDistance(from offsetA: Int, to offsetB: Int) -> Int {
|
||||
let smallChunkSize = baseCount / numberOfChunks
|
||||
let numberOfChunks = (offsetB - offsetA) - 1
|
||||
|
||||
|
||||
let largeChunksEnd = Swift.min(self.numberOfLargeChunks, offsetB)
|
||||
let largeChunksStart = Swift.min(self.numberOfLargeChunks, offsetA + 1)
|
||||
let numberOfLargeChunks = largeChunksEnd - largeChunksStart
|
||||
|
||||
|
||||
return smallChunkSize * numberOfChunks + numberOfLargeChunks
|
||||
}
|
||||
|
||||
|
||||
if distance == 0 {
|
||||
return i
|
||||
} else if distance > 0 {
|
||||
@@ -360,9 +366,13 @@ extension EvenlyChunkedCollection: Collection {
|
||||
return indexOfChunk(endingAt: end, offset: offset)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int, limitedBy limit: Index) -> Index? {
|
||||
public func index(
|
||||
_ i: Index,
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
if distance >= 0 {
|
||||
if (0..<distance).contains(self.distance(from: i, to: limit)) {
|
||||
return nil
|
||||
@@ -374,7 +384,7 @@ extension EvenlyChunkedCollection: Collection {
|
||||
}
|
||||
return index(i, offsetBy: distance)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
end.offset - start.offset
|
||||
@@ -384,8 +394,7 @@ extension EvenlyChunkedCollection: Collection {
|
||||
extension EvenlyChunkedCollection.Index: Hashable where Base.Index: Hashable {}
|
||||
|
||||
extension EvenlyChunkedCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
where Base: BidirectionalCollection {
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i != startIndex, "Can't advance before startIndex")
|
||||
@@ -394,13 +403,13 @@ extension EvenlyChunkedCollection: BidirectionalCollection
|
||||
}
|
||||
|
||||
extension EvenlyChunkedCollection: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension EvenlyChunkedCollection: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension EvenlyChunkedCollection: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// lazy.chunked(by:) / lazy.chunked(on:)
|
||||
@@ -411,7 +420,10 @@ extension LazySequenceProtocol where Self: Collection, Elements: Collection {
|
||||
/// the given predicate.
|
||||
///
|
||||
/// - Parameter belongInSameGroup: A closure that takes two adjacent elements
|
||||
/// of the sequence and returns whether or not they belong in the same group.
|
||||
/// of the sequence and returns whether or not they belong in the same
|
||||
/// group.
|
||||
/// - Returns: A collection of subsequences, with every pairwise group of
|
||||
/// elements in each chunk returning `true` for `belongInSameGroup`.
|
||||
///
|
||||
/// - Complexity: O(*n*), because the start index is pre-computed.
|
||||
@inlinable
|
||||
@@ -423,13 +435,15 @@ extension LazySequenceProtocol where Self: Collection, Elements: Collection {
|
||||
projection: { $0 },
|
||||
belongInSameGroup: belongInSameGroup)
|
||||
}
|
||||
|
||||
|
||||
/// Returns a lazy collection of subsequences of this collection, chunked by
|
||||
/// grouping elements that project to equal values.
|
||||
///
|
||||
/// - Parameter projection: A closure that takes an element in the sequence
|
||||
/// and returns an `Equatable` value that can be used to determine if adjacent
|
||||
/// elements belong in the same group.
|
||||
/// and returns an `Equatable` value that can be used to determine if
|
||||
/// adjacent elements belong in the same group.
|
||||
/// - Returns: A collection of subsequences, with every element in each chunk
|
||||
/// returning the same value for `projection`.
|
||||
///
|
||||
/// - Complexity: O(*n*), because the start index is pre-computed.
|
||||
@inlinable
|
||||
@@ -438,7 +452,8 @@ extension LazySequenceProtocol where Self: Collection, Elements: Collection {
|
||||
) -> ChunkedOnCollection<Elements, Subject> {
|
||||
ChunkedOnCollection(
|
||||
base: elements,
|
||||
projection: projection)
|
||||
projection: projection
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -451,8 +466,10 @@ extension Collection {
|
||||
/// given predicate.
|
||||
///
|
||||
/// - Parameter belongInSameGroup: A closure that takes two adjacent elements
|
||||
/// of the collection and returns whether or not they belong in the same
|
||||
/// group.
|
||||
/// of the collection and returns whether or not they belong in the same
|
||||
/// group.
|
||||
/// - Returns: A collection of subsequences, with every pairwise group of
|
||||
/// elements in each chunk returning `true` for `belongInSameGroup`.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
@inlinable
|
||||
@@ -461,10 +478,10 @@ extension Collection {
|
||||
) rethrows -> [SubSequence] {
|
||||
guard !isEmpty else { return [] }
|
||||
var result: [SubSequence] = []
|
||||
|
||||
|
||||
var start = startIndex
|
||||
var current = self[start]
|
||||
|
||||
|
||||
for (index, element) in indexed().dropFirst() {
|
||||
if try !belongInSameGroup(current, element) {
|
||||
result.append(self[start..<index])
|
||||
@@ -472,11 +489,11 @@ extension Collection {
|
||||
}
|
||||
current = element
|
||||
}
|
||||
|
||||
|
||||
if start != endIndex {
|
||||
result.append(self[start...])
|
||||
}
|
||||
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
@@ -484,8 +501,10 @@ extension Collection {
|
||||
/// grouping elements that project to equal values.
|
||||
///
|
||||
/// - Parameter projection: A closure that takes an element in the collection
|
||||
/// and returns an `Equatable` value that can be used to determine if adjacent
|
||||
/// elements belong in the same group.
|
||||
/// and returns an `Equatable` value that can be used to determine if
|
||||
/// adjacent elements belong in the same group.
|
||||
/// - Returns: A collection of subsequences, with every element in each chunk
|
||||
/// returning the same value for `projection`.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
@inlinable
|
||||
@@ -494,10 +513,10 @@ extension Collection {
|
||||
) rethrows -> [(Subject, SubSequence)] {
|
||||
guard !isEmpty else { return [] }
|
||||
var result: [(Subject, SubSequence)] = []
|
||||
|
||||
|
||||
var start = startIndex
|
||||
var subject = try projection(self[start])
|
||||
|
||||
|
||||
for (index, element) in indexed().dropFirst() {
|
||||
let nextSubject = try projection(element)
|
||||
if subject != nextSubject {
|
||||
@@ -506,11 +525,11 @@ extension Collection {
|
||||
subject = nextSubject
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if start != endIndex {
|
||||
result.append((subject, self[start...]))
|
||||
}
|
||||
|
||||
|
||||
return result
|
||||
}
|
||||
}
|
||||
@@ -532,13 +551,13 @@ extension Collection {
|
||||
/// `LazyMapCollection`
|
||||
public struct ChunksOfCountCollection<Base: Collection> {
|
||||
public typealias Element = Base.SubSequence
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let chunkCount: Int
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var endOfFirstChunk: Base.Index
|
||||
|
||||
@@ -550,13 +569,15 @@ public struct ChunksOfCountCollection<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.endOfFirstChunk = _base.index(
|
||||
_base.startIndex, offsetBy: _chunkCount,
|
||||
limitedBy: _base.endIndex
|
||||
) ?? _base.endIndex
|
||||
self.endOfFirstChunk =
|
||||
_base.index(
|
||||
_base.startIndex,
|
||||
offsetBy: _chunkCount,
|
||||
limitedBy: _base.endIndex
|
||||
) ?? _base.endIndex
|
||||
}
|
||||
}
|
||||
|
||||
@@ -564,7 +585,7 @@ extension ChunksOfCountCollection: Collection {
|
||||
public struct Index {
|
||||
@usableFromInline
|
||||
internal let baseRange: Range<Base.Index>
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(_baseRange: Range<Base.Index>) {
|
||||
self.baseRange = _baseRange
|
||||
@@ -576,40 +597,46 @@ extension ChunksOfCountCollection: Collection {
|
||||
public var startIndex: Index {
|
||||
Index(_baseRange: base.startIndex..<endOfFirstChunk)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
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 ChunksOfCountCollection.Index: Comparable {
|
||||
@inlinable
|
||||
public static func == (lhs: ChunksOfCountCollection.Index,
|
||||
rhs: ChunksOfCountCollection.Index) -> Bool {
|
||||
public static func == (
|
||||
lhs: ChunksOfCountCollection.Index,
|
||||
rhs: ChunksOfCountCollection.Index
|
||||
) -> Bool {
|
||||
lhs.baseRange.lowerBound == rhs.baseRange.lowerBound
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: ChunksOfCountCollection.Index,
|
||||
rhs: ChunksOfCountCollection.Index) -> Bool {
|
||||
public static func < (
|
||||
lhs: ChunksOfCountCollection.Index,
|
||||
rhs: ChunksOfCountCollection.Index
|
||||
) -> Bool {
|
||||
lhs.baseRange.lowerBound < rhs.baseRange.lowerBound
|
||||
}
|
||||
}
|
||||
@@ -620,7 +647,7 @@ 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
|
||||
@@ -628,11 +655,13 @@ where Base: RandomAccessCollection {
|
||||
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)
|
||||
}
|
||||
}
|
||||
@@ -641,10 +670,11 @@ extension ChunksOfCountCollection {
|
||||
@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)
|
||||
distance
|
||||
.quotientAndRemainder(dividingBy: chunkCount)
|
||||
return quotient + remainder.signum()
|
||||
}
|
||||
|
||||
@@ -654,14 +684,16 @@ extension ChunksOfCountCollection {
|
||||
base.count.quotientAndRemainder(dividingBy: chunkCount)
|
||||
return quotient + remainder.signum()
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ i: Index, offsetBy offset: Int, limitedBy limit: 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)
|
||||
@@ -676,33 +708,40 @@ extension ChunksOfCountCollection {
|
||||
@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
|
||||
_ i: Index,
|
||||
offsetBy distance: Int,
|
||||
limit: Index? = nil
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
|
||||
return makeOffsetIndex(
|
||||
from: i, baseBound: base.endIndex,
|
||||
distance: distance, baseDistance: distance * chunkCount,
|
||||
limit: limit, by: >
|
||||
from: i,
|
||||
baseBound: base.endIndex,
|
||||
distance: distance,
|
||||
baseDistance: distance * chunkCount,
|
||||
limit: limit,
|
||||
by: >
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
// Convenience to compute offset backward base distance.
|
||||
@inlinable
|
||||
internal func computeOffsetBackwardBaseDistance(
|
||||
_ i: Index, _ distance: Int
|
||||
_ i: Index,
|
||||
_ distance: Int
|
||||
) -> Int {
|
||||
if i == endIndex {
|
||||
let remainder = base.count % chunkCount
|
||||
@@ -716,32 +755,41 @@ extension ChunksOfCountCollection {
|
||||
}
|
||||
return distance * chunkCount
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ i: Index, offsetBy distance: Int, limit: Index? = nil
|
||||
_ i: Index,
|
||||
offsetBy distance: Int,
|
||||
limit: Index? = nil
|
||||
) -> Index? {
|
||||
assert(distance < 0)
|
||||
let baseDistance =
|
||||
computeOffsetBackwardBaseDistance(i, distance)
|
||||
let baseDistance = computeOffsetBackwardBaseDistance(i, distance)
|
||||
return makeOffsetIndex(
|
||||
from: i, baseBound: base.startIndex,
|
||||
distance: distance, baseDistance: baseDistance,
|
||||
limit: limit, by: <
|
||||
from: i,
|
||||
baseBound: base.startIndex,
|
||||
distance: distance,
|
||||
baseDistance: baseDistance,
|
||||
limit: limit,
|
||||
by: <
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
// Helper to compute `index(offsetBy:)` index.
|
||||
@inlinable
|
||||
internal func makeOffsetIndex(
|
||||
from i: Index, baseBound: Base.Index, distance: Int, baseDistance: Int,
|
||||
limit: Index?, by limitFn: (Base.Index, Base.Index) -> Bool
|
||||
from i: Index,
|
||||
baseBound: Base.Index,
|
||||
distance: Int,
|
||||
baseDistance: Int,
|
||||
limit: Index?,
|
||||
by limitFn: (Base.Index, Base.Index) -> Bool
|
||||
) -> Index? {
|
||||
let baseIdx = base.index(
|
||||
i.baseRange.lowerBound, offsetBy: baseDistance,
|
||||
i.baseRange.lowerBound,
|
||||
offsetBy: baseDistance,
|
||||
limitedBy: baseBound
|
||||
)
|
||||
|
||||
|
||||
if let limit = limit {
|
||||
if baseIdx == nil {
|
||||
// If we passed the bounds while advancing forward, and the limit is the
|
||||
@@ -766,12 +814,16 @@ extension ChunksOfCountCollection {
|
||||
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)
|
||||
}
|
||||
}
|
||||
@@ -818,10 +870,10 @@ extension Collection {
|
||||
extension ChunksOfCountCollection.Index: Hashable where Base.Index: Hashable {}
|
||||
|
||||
extension ChunksOfCountCollection: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension ChunksOfCountCollection: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// evenlyChunked(in:)
|
||||
@@ -868,7 +920,10 @@ extension Collection {
|
||||
@inlinable
|
||||
public func evenlyChunked(in count: Int) -> EvenlyChunkedCollection<Self> {
|
||||
precondition(count >= 0, "Can't divide into a negative number of chunks")
|
||||
precondition(count > 0 || isEmpty, "Can't divide a non-empty collection into 0 chunks")
|
||||
precondition(
|
||||
count > 0 || isEmpty,
|
||||
"Can't divide a non-empty collection into 0 chunks"
|
||||
)
|
||||
return EvenlyChunkedCollection(base: self, numberOfChunks: count)
|
||||
}
|
||||
}
|
||||
@@ -14,17 +14,17 @@ public struct CombinationsSequence<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 `CombinationsSequence` for all combinations of `base` of
|
||||
/// size `k`.
|
||||
///
|
||||
@@ -35,7 +35,7 @@ public struct CombinationsSequence<Base: Collection> {
|
||||
internal init(_ base: Base, k: Int) {
|
||||
self.init(base, kRange: k...k)
|
||||
}
|
||||
|
||||
|
||||
/// Initializes a `CombinationsSequence` for all combinations of `base` of
|
||||
/// sizes within a given range.
|
||||
///
|
||||
@@ -44,27 +44,29 @@ public struct CombinationsSequence<Base: Collection> {
|
||||
/// - kRange: The range of accepted sizes of combinations.
|
||||
@inlinable
|
||||
internal init<R: RangeExpression>(
|
||||
_ base: Base, kRange: R
|
||||
_ base: Base,
|
||||
kRange: R
|
||||
) where R.Bound == Int {
|
||||
let range = kRange.relative(to: 0 ..< .max)
|
||||
self.base = base
|
||||
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
|
||||
@@ -73,7 +75,7 @@ public struct CombinationsSequence<Base: Collection> {
|
||||
default: return n * binomial(n: n - 1, k: k - 1) / k
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return k.map {
|
||||
binomial(n: n, k: $0)
|
||||
}.reduce(0, +)
|
||||
@@ -89,7 +91,7 @@ extension CombinationsSequence: 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
|
||||
@@ -97,23 +99,23 @@ extension CombinationsSequence: Sequence {
|
||||
/// finished.
|
||||
@usableFromInline
|
||||
internal var kRange: Range<Int>
|
||||
|
||||
/// Whether or not iteration is finished (`kRange` is empty)
|
||||
|
||||
/// Whether or not iteration is finished (`kRange` is empty).
|
||||
@inlinable
|
||||
internal var isFinished: Bool {
|
||||
return kRange.isEmpty
|
||||
kRange.isEmpty
|
||||
}
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var indexes: [Base.Index]
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(_ combinations: CombinationsSequence) {
|
||||
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:
|
||||
@@ -139,12 +141,12 @@ extension CombinationsSequence: 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
|
||||
@@ -152,11 +154,11 @@ extension CombinationsSequence: 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
|
||||
@@ -165,7 +167,7 @@ extension CombinationsSequence: Sequence {
|
||||
advanceKRange()
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
base.formIndex(after: &indexes[j])
|
||||
for k in indexes.indices[(j + 1)...] {
|
||||
indexes[k] = base.index(after: indexes[k - 1])
|
||||
@@ -175,7 +177,7 @@ extension CombinationsSequence: Sequence {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> [Base.Element]? {
|
||||
guard !isFinished else { return nil }
|
||||
@@ -183,7 +185,7 @@ extension CombinationsSequence: Sequence {
|
||||
return indexes.map { i in base[i] }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(self)
|
||||
@@ -191,7 +193,7 @@ extension CombinationsSequence: Sequence {
|
||||
}
|
||||
|
||||
extension CombinationsSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// combinations(ofCount:)
|
||||
@@ -255,6 +257,8 @@ extension Collection {
|
||||
///
|
||||
/// - Parameter kRange: The range of numbers of elements to include in each
|
||||
/// combination.
|
||||
/// - Returns: A sequence of the combinations of this collection's
|
||||
/// elements, for all sizes in `kRange`, from smallest to largest.
|
||||
///
|
||||
/// - Complexity: O(1) for random-access base collections. O(*n*) where *n*
|
||||
/// is the number of elements in the base collection, since
|
||||
@@ -265,7 +269,7 @@ extension Collection {
|
||||
) -> CombinationsSequence<Self> where R.Bound == Int {
|
||||
CombinationsSequence(self, kRange: kRange)
|
||||
}
|
||||
|
||||
|
||||
/// Returns a collection of combinations of this collection's elements, with
|
||||
/// each combination having the specified number of elements.
|
||||
///
|
||||
@@ -291,13 +295,17 @@ extension Collection {
|
||||
/// the resulting sequence has no elements.
|
||||
///
|
||||
/// - Parameter k: The number of elements to include in each combination.
|
||||
/// - Returns: A sequence of the combinations of this collection's
|
||||
/// elements.
|
||||
///
|
||||
/// - Complexity: O(1) for random-access base collections. O(*n*) where *n*
|
||||
/// is the number of elements in the base collection, since
|
||||
/// `CombinationsSequence` accesses the `count` of the base collection.
|
||||
@inlinable
|
||||
public func combinations(ofCount k: Int) -> CombinationsSequence<Self> {
|
||||
precondition(k >= 0, "Can't have combinations with a negative number of elements.")
|
||||
precondition(
|
||||
k >= 0,
|
||||
"Can't have combinations with a negative number of elements.")
|
||||
return CombinationsSequence(self, k: k)
|
||||
}
|
||||
}
|
||||
@@ -12,11 +12,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
|
||||
@@ -25,12 +25,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() {
|
||||
@@ -68,7 +68,7 @@ extension Sequence {
|
||||
/// Complexity: O(1)
|
||||
@inlinable
|
||||
public func compacted<Unwrapped>() -> CompactedSequence<Self, Unwrapped>
|
||||
where Element == Unwrapped? {
|
||||
where Element == Unwrapped? {
|
||||
CompactedSequence(base: self)
|
||||
}
|
||||
}
|
||||
@@ -76,74 +76,79 @@ extension Sequence {
|
||||
/// 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 {
|
||||
// swift-format-ignore: NeverForceUnwrap
|
||||
// All indices are only for non-`nil` elements.
|
||||
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 from
|
||||
@@ -167,8 +172,7 @@ extension Collection {
|
||||
/// original `Collection`.
|
||||
@inlinable
|
||||
public func compacted<Unwrapped>() -> CompactedCollection<Self, Unwrapped>
|
||||
where Element == Unwrapped?
|
||||
{
|
||||
where Element == Unwrapped? {
|
||||
CompactedCollection(base: self)
|
||||
}
|
||||
}
|
||||
@@ -178,7 +182,7 @@ extension Collection {
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension CompactedSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension CompactedCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
@@ -14,7 +14,7 @@ public struct CycledSequence<Base: Collection> {
|
||||
/// The collection to repeat.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base) {
|
||||
self.base = base
|
||||
@@ -26,29 +26,29 @@ extension CycledSequence: 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)
|
||||
@@ -56,7 +56,7 @@ extension CycledSequence: Sequence {
|
||||
}
|
||||
|
||||
extension CycledSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
/// A collection wrapper that repeats the elements of a base collection for a
|
||||
/// finite number of times.
|
||||
@@ -134,10 +134,11 @@ extension CycledTimesCollection: Collection {
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
guard let productIndex = product.index(
|
||||
i.productIndex,
|
||||
offsetBy: distance,
|
||||
limitedBy: limit.productIndex)
|
||||
guard
|
||||
let productIndex = product.index(
|
||||
i.productIndex,
|
||||
offsetBy: distance,
|
||||
limitedBy: limit.productIndex)
|
||||
else { return nil }
|
||||
return Index(productIndex)
|
||||
}
|
||||
@@ -149,7 +150,7 @@ extension CycledTimesCollection: Collection {
|
||||
}
|
||||
|
||||
extension CycledTimesCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection {
|
||||
where Base: BidirectionalCollection {
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
let productIndex = product.index(before: i.productIndex)
|
||||
@@ -158,10 +159,10 @@ extension CycledTimesCollection: BidirectionalCollection
|
||||
}
|
||||
|
||||
extension CycledTimesCollection: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension CycledTimesCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// cycled()
|
||||
@@ -197,7 +198,7 @@ extension Collection {
|
||||
public func cycled() -> CycledSequence<Self> {
|
||||
CycledSequence(base: self)
|
||||
}
|
||||
|
||||
|
||||
/// Returns a sequence that repeats the elements of this collection the
|
||||
/// specified number of times.
|
||||
///
|
||||
|
||||
@@ -24,9 +24,9 @@ extension Either: Equatable where Left: Equatable, Right: Equatable {
|
||||
@usableFromInline
|
||||
internal static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
switch (lhs, rhs) {
|
||||
case let (.left(lhs), .left(rhs)):
|
||||
case (.left(let lhs), .left(let rhs)):
|
||||
return lhs == rhs
|
||||
case let (.right(lhs), .right(rhs)):
|
||||
case (.right(let lhs), .right(let rhs)):
|
||||
return lhs == rhs
|
||||
case (.left, .right), (.right, .left):
|
||||
return false
|
||||
@@ -38,9 +38,9 @@ extension Either: Comparable where Left: Comparable, Right: Comparable {
|
||||
@usableFromInline
|
||||
internal static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
switch (lhs, rhs) {
|
||||
case let (.left(lhs), .left(rhs)):
|
||||
case (.left(let lhs), .left(let rhs)):
|
||||
return lhs < rhs
|
||||
case let (.right(lhs), .right(rhs)):
|
||||
case (.right(let lhs), .right(let rhs)):
|
||||
return lhs < rhs
|
||||
case (.left, .right):
|
||||
return true
|
||||
@@ -57,8 +57,7 @@ extension Either: Comparable where Left: Comparable, Right: Comparable {
|
||||
/// A sequence that has one of the two specified types.
|
||||
@usableFromInline
|
||||
internal enum EitherSequence<Left: Sequence, Right: Sequence>
|
||||
where Left.Element == Right.Element
|
||||
{
|
||||
where Left.Element == Right.Element {
|
||||
case left(Left)
|
||||
case right(Right)
|
||||
}
|
||||
@@ -68,16 +67,16 @@ extension EitherSequence: Sequence {
|
||||
internal struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var left: Left.Iterator?
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var right: Right.Iterator?
|
||||
|
||||
|
||||
@inlinable
|
||||
internal mutating func next() -> Left.Element? {
|
||||
left?.next() ?? right?.next()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal func makeIterator() -> Iterator {
|
||||
switch self {
|
||||
@@ -90,8 +89,7 @@ extension EitherSequence: Sequence {
|
||||
}
|
||||
|
||||
extension EitherSequence: Collection
|
||||
where Left: Collection, Right: Collection, Left.Element == Right.Element
|
||||
{
|
||||
where Left: Collection, Right: Collection, Left.Element == Right.Element {
|
||||
@usableFromInline
|
||||
internal typealias Index = Either<Left.Index, Right.Index>
|
||||
|
||||
@@ -118,9 +116,9 @@ extension EitherSequence: Collection
|
||||
@inlinable
|
||||
internal subscript(position: Index) -> Element {
|
||||
switch (self, position) {
|
||||
case let (.left(s), .left(i)):
|
||||
case (.left(let s), .left(let i)):
|
||||
return s[i]
|
||||
case let (.right(s), .right(i)):
|
||||
case (.right(let s), .right(let i)):
|
||||
return s[i]
|
||||
default:
|
||||
fatalError()
|
||||
@@ -129,10 +127,10 @@ extension EitherSequence: Collection
|
||||
|
||||
@inlinable
|
||||
internal func index(after i: Index) -> Index {
|
||||
switch (self,i) {
|
||||
case let (.left(s), .left(i)):
|
||||
switch (self, i) {
|
||||
case (.left(let s), .left(let i)):
|
||||
return .left(s.index(after: i))
|
||||
case let (.right(s), .right(i)):
|
||||
case (.right(let s), .right(let i)):
|
||||
return .right(s.index(after: i))
|
||||
default:
|
||||
fatalError()
|
||||
@@ -146,9 +144,9 @@ extension EitherSequence: Collection
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
switch (self, i, limit) {
|
||||
case let (.left(s), .left(i), .left(limit)):
|
||||
case (.left(let s), .left(let i), .left(let limit)):
|
||||
return s.index(i, offsetBy: distance, limitedBy: limit).map { .left($0) }
|
||||
case let (.right(s), .right(i), .right(limit)):
|
||||
case (.right(let s), .right(let i), .right(let limit)):
|
||||
return s.index(i, offsetBy: distance, limitedBy: limit).map { .right($0) }
|
||||
default:
|
||||
fatalError()
|
||||
@@ -158,9 +156,9 @@ extension EitherSequence: Collection
|
||||
@inlinable
|
||||
internal func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
switch (self, i) {
|
||||
case let (.left(s), .left(i)):
|
||||
case (.left(let s), .left(let i)):
|
||||
return .left(s.index(i, offsetBy: distance))
|
||||
case let (.right(s), .right(i)):
|
||||
case (.right(let s), .right(let i)):
|
||||
return .right(s.index(i, offsetBy: distance))
|
||||
default:
|
||||
fatalError()
|
||||
@@ -170,9 +168,9 @@ extension EitherSequence: Collection
|
||||
@inlinable
|
||||
internal func distance(from start: Index, to end: Index) -> Int {
|
||||
switch (self, start, end) {
|
||||
case let (.left(s), .left(i), .left(j)):
|
||||
case (.left(let s), .left(let i), .left(let j)):
|
||||
return s.distance(from: i, to: j)
|
||||
case let (.right(s), .right(i), .right(j)):
|
||||
case (.right(let s), .right(let i), .right(let j)):
|
||||
return s.distance(from: i, to: j)
|
||||
default:
|
||||
fatalError()
|
||||
@@ -181,14 +179,13 @@ extension EitherSequence: Collection
|
||||
}
|
||||
|
||||
extension EitherSequence: BidirectionalCollection
|
||||
where Left: BidirectionalCollection, Right: BidirectionalCollection
|
||||
{
|
||||
where Left: BidirectionalCollection, Right: BidirectionalCollection {
|
||||
@inlinable
|
||||
internal func index(before i: Index) -> Index {
|
||||
switch (self, i) {
|
||||
case let (.left(s), .left(i)):
|
||||
case (.left(let s), .left(let i)):
|
||||
return .left(s.index(before: i))
|
||||
case let (.right(s), .right(i)):
|
||||
case (.right(let s), .right(let i)):
|
||||
return .right(s.index(before: i))
|
||||
default:
|
||||
fatalError()
|
||||
@@ -197,4 +194,4 @@ extension EitherSequence: BidirectionalCollection
|
||||
}
|
||||
|
||||
extension EitherSequence: RandomAccessCollection
|
||||
where Left: RandomAccessCollection, Right: RandomAccessCollection {}
|
||||
where Left: RandomAccessCollection, Right: RandomAccessCollection {}
|
||||
@@ -0,0 +1,83 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2021 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// EndsWith
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension BidirectionalCollection where Element: Equatable {
|
||||
/// Returns a Boolean value indicating whether the final elements of the
|
||||
/// collection are the same as the elements in another collection.
|
||||
///
|
||||
/// This example tests whether one countable range ends with the elements
|
||||
/// of another countable range.
|
||||
///
|
||||
/// let a = 8...10
|
||||
/// let b = 1...10
|
||||
///
|
||||
/// print(b.ends(with: a))
|
||||
/// // Prints "true"
|
||||
///
|
||||
/// Passing a collection with no elements or an empty collection as
|
||||
/// `possibleSuffix` always results in `true`.
|
||||
///
|
||||
/// print(b.ends(with: []))
|
||||
/// // Prints "true"
|
||||
///
|
||||
/// - Parameter possibleSuffix: A collection to compare to this collection.
|
||||
/// - Returns: `true` if the initial elements of the collection are the same as
|
||||
/// the elements of `possibleSuffix`; otherwise, `false`. If
|
||||
/// `possibleSuffix` has no elements, the return value is `true`.
|
||||
///
|
||||
/// - Complexity: O(*m*), where *m* is the lesser of the length of the
|
||||
/// collection and the length of `possibleSuffix`.
|
||||
@inlinable
|
||||
public func ends<PossibleSuffix: BidirectionalCollection>(
|
||||
with possibleSuffix: PossibleSuffix
|
||||
) -> Bool where PossibleSuffix.Element == Element {
|
||||
self.ends(with: possibleSuffix, by: ==)
|
||||
}
|
||||
}
|
||||
|
||||
extension BidirectionalCollection {
|
||||
/// Returns a Boolean value indicating whether the final elements of the
|
||||
/// collection are equivalent to the elements in another collection, using
|
||||
/// the given predicate as the equivalence test.
|
||||
///
|
||||
/// The predicate must be an *equivalence relation* over the elements. That
|
||||
/// is, for any elements `a`, `b`, and `c`, the following conditions must
|
||||
/// hold:
|
||||
///
|
||||
/// - `areEquivalent(a, a)` is always `true`. (Reflexivity)
|
||||
/// - `areEquivalent(a, b)` implies `areEquivalent(b, a)`. (Symmetry)
|
||||
/// - If `areEquivalent(a, b)` and `areEquivalent(b, c)` are both `true`, then
|
||||
/// `areEquivalent(a, c)` is also `true`. (Transitivity)
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - possibleSuffix: A collection to compare to this collection.
|
||||
/// - areEquivalent: A predicate that returns `true` if its two arguments
|
||||
/// are equivalent; otherwise, `false`.
|
||||
/// - Returns: `true` if the initial elements of the collection are equivalent
|
||||
/// to the elements of `possibleSuffix`; otherwise, `false`. If
|
||||
/// `possibleSuffix` has no elements, the return value is `true`.
|
||||
///
|
||||
/// - Complexity: O(*m*), where *m* is the lesser of the length of the
|
||||
/// collection and the length of `possibleSuffix`.
|
||||
@inlinable
|
||||
public func ends<PossibleSuffix: BidirectionalCollection>(
|
||||
with possibleSuffix: PossibleSuffix,
|
||||
by areEquivalent: (Element, PossibleSuffix.Element) throws -> Bool
|
||||
) rethrows -> Bool {
|
||||
try self
|
||||
.reversed()
|
||||
.starts(with: possibleSuffix.reversed(), by: areEquivalent)
|
||||
}
|
||||
}
|
||||
@@ -13,14 +13,13 @@
|
||||
/// collections.
|
||||
@usableFromInline
|
||||
internal struct FlattenCollection<Base: Collection>
|
||||
where Base.Element: Collection
|
||||
{
|
||||
where Base.Element: Collection {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let indexOfFirstNonEmptyElement: Base.Index
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base) {
|
||||
self.base = base
|
||||
@@ -33,35 +32,39 @@ extension FlattenCollection: Collection {
|
||||
internal struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal let outer: Base.Index
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let inner: Base.Element.Index?
|
||||
|
||||
|
||||
@inlinable
|
||||
init(outer: Base.Index, inner: Base.Element.Index?) {
|
||||
self.outer = outer
|
||||
self.inner = inner
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
guard lhs.outer == rhs.outer else { return lhs.outer < rhs.outer }
|
||||
// swift-format-ignore: NeverForceUnwrap
|
||||
// `inner` is nil iff `outer` is `base.endIndex`, and the
|
||||
// previous line established that the two outer indices are equal.
|
||||
// Thus, either both inner indices are nil or neither are.
|
||||
return lhs.inner == nil ? false : lhs.inner! < rhs.inner!
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal var startIndex: Index {
|
||||
let outer = indexOfFirstNonEmptyElement
|
||||
let inner = outer == base.endIndex ? nil : base[outer].startIndex
|
||||
return Index(outer: outer, inner: inner)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal var endIndex: Index {
|
||||
Index(outer: base.endIndex, inner: nil)
|
||||
}
|
||||
|
||||
|
||||
/// Forms an index from a pair of base indices, normalizing
|
||||
/// `(i, base2.endIndex)` to `(base1.index(after: i), base2.startIndex)` if
|
||||
/// necessary.
|
||||
@@ -70,56 +73,64 @@ extension FlattenCollection: Collection {
|
||||
outer: Base.Index,
|
||||
inner: Base.Element.Index
|
||||
) -> Index {
|
||||
if inner == base[outer].endIndex {
|
||||
let outer = base[base.index(after: outer)...]
|
||||
.endOfPrefix(while: { $0.isEmpty })
|
||||
let inner = outer == base.endIndex ? nil : base[outer].startIndex
|
||||
return Index(outer: outer, inner: inner)
|
||||
} else {
|
||||
guard inner == base[outer].endIndex else {
|
||||
return Index(outer: outer, inner: inner)
|
||||
}
|
||||
let outer = base[base.index(after: outer)...]
|
||||
.endOfPrefix(while: { $0.isEmpty })
|
||||
let inner = outer == base.endIndex ? nil : base[outer].startIndex
|
||||
return Index(outer: outer, inner: inner)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func index(after index: Index) -> Index {
|
||||
let element = base[index.outer]
|
||||
// swift-format-ignore: NeverForceUnwrap
|
||||
// This unwrap, like the unchecked subscript above, enforces the
|
||||
// precondition that you can't advance past `endIndex`.
|
||||
let nextInner = element.index(after: index.inner!)
|
||||
return normalizeIndex(outer: index.outer, inner: nextInner)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal subscript(position: Index) -> Base.Element.Element {
|
||||
// swift-format-ignore: NeverForceUnwrap
|
||||
// This unwrap, along with the unchecked subscript, enforces the
|
||||
// precondition that you can't subscript at `endIndex`.
|
||||
base[position.outer][position.inner!]
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func distance(from start: Index, to end: Index) -> Int {
|
||||
guard start.outer <= end.outer
|
||||
else { return -distance(from: end, to: start) }
|
||||
else { return -distance(from: end, to: start) }
|
||||
guard let startInner = start.inner
|
||||
else { return 0 }
|
||||
else { return 0 }
|
||||
guard start.outer != end.outer
|
||||
else {
|
||||
return base[start.outer].distance(from: startInner, to: end.inner!)
|
||||
}
|
||||
|
||||
else {
|
||||
// swift-format-ignore: NeverForceUnwrap
|
||||
// Established via guards that outer indices are equal and `start.inner`
|
||||
// is non-nil, so `end.inner` must also be non-`nil`.
|
||||
return base[start.outer].distance(from: startInner, to: end.inner!)
|
||||
}
|
||||
|
||||
let firstPart = base[start.outer][startInner...].count
|
||||
let middlePart = base[start.outer..<end.outer].dropFirst()
|
||||
.reduce(0, { $0 + $1.count })
|
||||
let lastPart = end.inner.map { base[end.outer][..<$0].count } ?? 0
|
||||
|
||||
|
||||
return firstPart + middlePart + lastPart
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func index(_ index: Index, offsetBy distance: Int) -> Index {
|
||||
guard distance != 0 else { return index }
|
||||
|
||||
|
||||
return distance > 0
|
||||
? offsetForward(index, by: distance)
|
||||
: offsetBackward(index, by: -distance)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func index(
|
||||
_ index: Index,
|
||||
@@ -127,7 +138,7 @@ extension FlattenCollection: Collection {
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
guard distance != 0 else { return index }
|
||||
|
||||
|
||||
if distance > 0 {
|
||||
return limit >= index
|
||||
? offsetForward(index, by: distance, limitedBy: limit)
|
||||
@@ -138,133 +149,139 @@ extension FlattenCollection: Collection {
|
||||
: offsetBackward(index, 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(
|
||||
_ index: Index, by distance: Int, limitedBy limit: Index
|
||||
_ index: Index,
|
||||
by distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
assert(limit >= index)
|
||||
|
||||
|
||||
if index.outer == limit.outer {
|
||||
if let indexInner = index.inner, let limitInner = limit.inner {
|
||||
return base[index.outer]
|
||||
.index(indexInner, offsetBy: distance, limitedBy: limitInner)
|
||||
.map { inner in Index(outer: index.outer, inner: inner) }
|
||||
} else {
|
||||
guard let indexInner = index.inner, let limitInner = limit.inner else {
|
||||
// `index` and `limit` are both `endIndex`
|
||||
return nil
|
||||
}
|
||||
return base[index.outer]
|
||||
.index(indexInner, offsetBy: distance, limitedBy: limitInner)
|
||||
.map { inner in Index(outer: index.outer, inner: inner) }
|
||||
}
|
||||
|
||||
|
||||
// swift-format-ignore: NeverForceUnwrap
|
||||
// `index <= limit` and `index.outer != limit.outer`, so `index != endIndex`
|
||||
let indexInner = index.inner!
|
||||
let element = base[index.outer]
|
||||
|
||||
|
||||
if let inner = element.index(
|
||||
indexInner,
|
||||
offsetBy: distance,
|
||||
limitedBy: element.endIndex
|
||||
indexInner,
|
||||
offsetBy: distance,
|
||||
limitedBy: element.endIndex
|
||||
) {
|
||||
return normalizeIndex(outer: index.outer, inner: inner)
|
||||
}
|
||||
|
||||
|
||||
var remainder = distance - element[indexInner...].count
|
||||
var outer = base.index(after: index.outer)
|
||||
|
||||
|
||||
while outer != limit.outer {
|
||||
let element = base[outer]
|
||||
|
||||
|
||||
if let inner = element.index(
|
||||
element.startIndex,
|
||||
offsetBy: remainder,
|
||||
limitedBy: element.endIndex
|
||||
element.startIndex,
|
||||
offsetBy: remainder,
|
||||
limitedBy: element.endIndex
|
||||
) {
|
||||
return normalizeIndex(outer: outer, inner: inner)
|
||||
}
|
||||
|
||||
|
||||
remainder -= element.count
|
||||
base.formIndex(after: &outer)
|
||||
}
|
||||
|
||||
|
||||
if let limitInner = limit.inner {
|
||||
let element = base[outer]
|
||||
return element.index(
|
||||
element.startIndex,
|
||||
offsetBy: remainder,
|
||||
limitedBy: limitInner)
|
||||
.map { inner in Index(outer: outer, inner: inner) }
|
||||
} else {
|
||||
return nil
|
||||
limitedBy: limitInner
|
||||
)
|
||||
.map { inner in Index(outer: outer, inner: inner) }
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ index: Index, by distance: Int, limitedBy limit: Index
|
||||
_ index: Index,
|
||||
by distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
assert(limit <= index)
|
||||
|
||||
|
||||
if index.outer == limit.outer {
|
||||
if let indexInner = index.inner, let limitInner = limit.inner {
|
||||
return base[index.outer]
|
||||
.index(indexInner, offsetBy: -distance, limitedBy: limitInner)
|
||||
.map { inner in Index(outer: index.outer, inner: inner) }
|
||||
} else {
|
||||
guard let indexInner = index.inner, let limitInner = limit.inner else {
|
||||
// `index` and `limit` are both `endIndex`
|
||||
return nil
|
||||
}
|
||||
return base[index.outer]
|
||||
.index(indexInner, offsetBy: -distance, limitedBy: limitInner)
|
||||
.map { inner in Index(outer: index.outer, inner: inner) }
|
||||
}
|
||||
|
||||
|
||||
var remainder = distance
|
||||
|
||||
|
||||
if let indexInner = index.inner {
|
||||
let element = base[index.outer]
|
||||
|
||||
|
||||
if let inner = element.index(
|
||||
indexInner,
|
||||
offsetBy: -remainder,
|
||||
limitedBy: element.startIndex
|
||||
indexInner,
|
||||
offsetBy: -remainder,
|
||||
limitedBy: element.startIndex
|
||||
) {
|
||||
return Index(outer: index.outer, inner: inner)
|
||||
}
|
||||
|
||||
|
||||
remainder -= element[..<indexInner].count
|
||||
}
|
||||
|
||||
|
||||
var outer = base.index(index.outer, offsetBy: -1)
|
||||
|
||||
|
||||
while outer != limit.outer {
|
||||
let element = base[outer]
|
||||
|
||||
|
||||
if let inner = element.index(
|
||||
element.endIndex,
|
||||
offsetBy: -remainder,
|
||||
limitedBy: element.startIndex
|
||||
element.endIndex,
|
||||
offsetBy: -remainder,
|
||||
limitedBy: element.startIndex
|
||||
) {
|
||||
return Index(outer: outer, inner: inner)
|
||||
}
|
||||
|
||||
|
||||
remainder -= element.count
|
||||
base.formIndex(&outer, offsetBy: -1)
|
||||
}
|
||||
|
||||
|
||||
let element = base[outer]
|
||||
// swift-format-ignore: NeverForceUnwrap
|
||||
// At start of function, `limit <= index`, and checked for
|
||||
// `limit == endIndex`.
|
||||
return element.index(
|
||||
element.endIndex,
|
||||
offsetBy: -remainder,
|
||||
@@ -274,20 +291,24 @@ extension FlattenCollection: Collection {
|
||||
}
|
||||
|
||||
extension FlattenCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection, Base.Element: BidirectionalCollection
|
||||
{
|
||||
where Base: BidirectionalCollection, Base.Element: BidirectionalCollection {
|
||||
@inlinable
|
||||
internal func index(before index: Index) -> Index {
|
||||
if let inner = index.inner {
|
||||
let element = base[index.outer]
|
||||
|
||||
|
||||
if inner != element.startIndex {
|
||||
let previousInner = element.index(before: inner)
|
||||
return Index(outer: index.outer, inner: previousInner)
|
||||
}
|
||||
}
|
||||
|
||||
let previousOuter = base[..<index.outer].lastIndex(where: { !$0.isEmpty })!
|
||||
|
||||
guard
|
||||
let previousOuter = base[..<index.outer]
|
||||
.lastIndex(where: { !$0.isEmpty })
|
||||
else {
|
||||
fatalError("Can't move before startIndex.")
|
||||
}
|
||||
let element = base[previousOuter]
|
||||
let previousInner = element.index(before: element.endIndex)
|
||||
return Index(outer: previousOuter, inner: previousInner)
|
||||
@@ -295,7 +316,7 @@ extension FlattenCollection: BidirectionalCollection
|
||||
}
|
||||
|
||||
extension FlattenCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazySequenceProtocol, Base.Element: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol, Base.Element: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// joined()
|
||||
|
||||
@@ -10,16 +10,18 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Sequence {
|
||||
/// Groups up elements of `self` into a new Dictionary,
|
||||
/// whose values are Arrays of grouped elements,
|
||||
/// each keyed by the group key returned by the given closure.
|
||||
/// - Parameters:
|
||||
/// - keyForValue: A closure that returns a key for each element in
|
||||
/// `self`.
|
||||
/// Groups elements of this sequence into a new dictionary,
|
||||
/// whose values are arrays of grouped elements,
|
||||
/// each keyed by the key returned by the given closure.
|
||||
///
|
||||
/// - Parameter keyForValue: A closure that returns a key for each element
|
||||
/// in the sequence.
|
||||
/// - Returns: A dictionary containing grouped elements of self, keyed by
|
||||
/// the keys derived by the `keyForValue` closure.
|
||||
/// the keys derived by the `keyForValue` closure.
|
||||
@inlinable
|
||||
public func grouped<GroupKey>(by keyForValue: (Element) throws -> GroupKey) rethrows -> [GroupKey: [Element]] {
|
||||
public func grouped<GroupKey>(
|
||||
by keyForValue: (Element) throws -> GroupKey
|
||||
) rethrows -> [GroupKey: [Element]] {
|
||||
try Dictionary(grouping: self, by: keyForValue)
|
||||
}
|
||||
}
|
||||
@@ -15,7 +15,7 @@ public struct IndexedCollection<Base: Collection> {
|
||||
/// The base collection.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base) {
|
||||
self.base = base
|
||||
@@ -25,32 +25,32 @@ public struct IndexedCollection<Base: Collection> {
|
||||
extension IndexedCollection: Collection {
|
||||
/// The element type for an `IndexedCollection` collection.
|
||||
public typealias Element = (index: Base.Index, element: Base.Element)
|
||||
|
||||
|
||||
@inlinable
|
||||
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,
|
||||
@@ -59,12 +59,12 @@ extension IndexedCollection: Collection {
|
||||
) -> 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)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var indices: Base.Indices {
|
||||
base.indices
|
||||
@@ -72,8 +72,7 @@ extension IndexedCollection: Collection {
|
||||
}
|
||||
|
||||
extension IndexedCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
where Base: BidirectionalCollection {
|
||||
@inlinable
|
||||
public func index(before i: Base.Index) -> Base.Index {
|
||||
base.index(before: i)
|
||||
@@ -81,10 +80,10 @@ extension IndexedCollection: BidirectionalCollection
|
||||
}
|
||||
|
||||
extension IndexedCollection: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension IndexedCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// indexed()
|
||||
|
||||
@@ -18,10 +18,10 @@
|
||||
public struct InterspersedSequence<Base: Sequence> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let separator: Base.Element
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, separator: Base.Element) {
|
||||
self.base = base
|
||||
@@ -38,16 +38,16 @@ extension InterspersedSequence: Sequence {
|
||||
case element(Base.Element)
|
||||
case separator
|
||||
}
|
||||
|
||||
|
||||
@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
|
||||
@@ -89,7 +89,7 @@ extension InterspersedSequence: Collection where Base: Collection {
|
||||
case element(Base.Index)
|
||||
case separator(next: Base.Index)
|
||||
}
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let representation: Representation
|
||||
|
||||
@@ -101,15 +101,15 @@ extension InterspersedSequence: Collection where Base: Collection {
|
||||
@inlinable
|
||||
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)):
|
||||
case (.element(let li), .element(let ri)),
|
||||
(.separator(next: let li), .separator(next: let ri)),
|
||||
(.element(let li), .separator(next: let ri)):
|
||||
return li < ri
|
||||
case let (.separator(next: li), .element(ri)):
|
||||
case (.separator(next: let li), .element(let ri)):
|
||||
return li <= ri
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal static func element(_ index: Base.Index) -> Self {
|
||||
Self(representation: .element(index))
|
||||
@@ -135,9 +135,9 @@ extension InterspersedSequence: Collection where Base: Collection {
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i != endIndex, "Can't advance past endIndex")
|
||||
switch i.representation {
|
||||
case let .element(index):
|
||||
case .element(let index):
|
||||
return .separator(next: base.index(after: index))
|
||||
case let .separator(next):
|
||||
case .separator(let next):
|
||||
return .element(next)
|
||||
}
|
||||
}
|
||||
@@ -149,20 +149,20 @@ extension InterspersedSequence: Collection where Base: Collection {
|
||||
case .separator: return separator
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
switch (start.representation, end.representation) {
|
||||
case let (.element(element), .separator(next: separator)):
|
||||
case (.element(let element), .separator(next: let separator)):
|
||||
return 2 * base.distance(from: element, to: separator) - 1
|
||||
case let (.separator(next: separator), .element(element)):
|
||||
case (.separator(next: let separator), .element(let element)):
|
||||
return 2 * base.distance(from: separator, to: element) + 1
|
||||
case let (.element(start), .element(end)),
|
||||
let (.separator(start), .separator(end)):
|
||||
case (.element(let start), .element(let end)),
|
||||
(.separator(let start), .separator(let end)):
|
||||
return 2 * base.distance(from: start, to: end)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(_ index: Index, offsetBy distance: Int) -> Index {
|
||||
distance >= 0
|
||||
@@ -172,84 +172,94 @@ extension InterspersedSequence: Collection where Base: Collection {
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ index: Index,
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
if distance >= 0 {
|
||||
return limit >= index
|
||||
? offsetForward(index, by: distance, limitedBy: limit)
|
||||
: offsetForward(index, by: distance)
|
||||
} else {
|
||||
return limit <= index
|
||||
? offsetBackward(index, by: -distance, limitedBy: limit)
|
||||
: offsetBackward(index, by: -distance)
|
||||
}
|
||||
_ index: Index,
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
if distance >= 0 {
|
||||
return limit >= index
|
||||
? offsetForward(index, by: distance, limitedBy: limit)
|
||||
: offsetForward(index, by: distance)
|
||||
} else {
|
||||
return limit <= index
|
||||
? offsetBackward(index, by: -distance, limitedBy: limit)
|
||||
: offsetBackward(index, 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(
|
||||
_ index: Index, by distance: Int, limitedBy limit: Index
|
||||
_ index: Index,
|
||||
by distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance >= 0)
|
||||
assert(limit >= index)
|
||||
|
||||
switch (index.representation, limit.representation, distance.isMultiple(of: 2)) {
|
||||
case let (.element(index), .element(limit), true),
|
||||
let (.separator(next: index), .element(limit), false):
|
||||
|
||||
switch (
|
||||
index.representation, limit.representation, distance.isMultiple(of: 2)
|
||||
) {
|
||||
case (.element(let index), .element(let limit), true),
|
||||
(.separator(next: let index), .element(let limit), false):
|
||||
return base.index(index, offsetBy: distance / 2, limitedBy: limit)
|
||||
.map { .element($0) }
|
||||
|
||||
case let (.element(index), .element(limit), false),
|
||||
let (.element(index), .separator(next: limit), false),
|
||||
let (.separator(next: index), .element(limit), true),
|
||||
let (.separator(next: index), .separator(next: limit), true):
|
||||
|
||||
case (.element(let index), .element(let limit), false),
|
||||
(.element(let index), .separator(next: let limit), false),
|
||||
(.separator(next: let index), .element(let limit), true),
|
||||
(.separator(next: let index), .separator(next: let limit), true):
|
||||
return base.index(index, offsetBy: (distance + 1) / 2, limitedBy: limit)
|
||||
.map { .separator(next: $0) }
|
||||
|
||||
case let (.element(index), .separator(next: limit), true),
|
||||
let (.separator(next: index), .separator(next: limit), false):
|
||||
|
||||
case (.element(let index), .separator(next: let limit), true),
|
||||
(.separator(next: let index), .separator(next: let limit), false):
|
||||
return base.index(index, offsetBy: distance / 2, limitedBy: limit)
|
||||
.flatMap { $0 == limit ? nil : .element($0) }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ index: Index, by distance: Int, limitedBy limit: Index
|
||||
_ index: Index,
|
||||
by distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance >= 0)
|
||||
assert(limit <= index)
|
||||
|
||||
switch (index.representation, limit.representation, distance.isMultiple(of: 2)) {
|
||||
case let (.element(index), .element(limit), true),
|
||||
let (.element(index), .separator(next: limit), true),
|
||||
let (.separator(next: index), .element(limit), false),
|
||||
let (.separator(next: index), .separator(next: limit), false):
|
||||
return base.index(index, offsetBy: -((distance + 1) / 2), limitedBy: limit)
|
||||
.map { .element($0) }
|
||||
|
||||
case let (.element(index), .separator(next: limit), false),
|
||||
let (.separator(next: index), .separator(next: limit), true):
|
||||
|
||||
switch (
|
||||
index.representation, limit.representation, distance.isMultiple(of: 2)
|
||||
) {
|
||||
case (.element(let index), .element(let limit), true),
|
||||
(.element(let index), .separator(next: let limit), true),
|
||||
(.separator(next: let index), .element(let limit), false),
|
||||
(.separator(next: let index), .separator(next: let limit), false):
|
||||
return base.index(
|
||||
index, offsetBy: -((distance + 1) / 2), limitedBy: limit
|
||||
)
|
||||
.map { .element($0) }
|
||||
|
||||
case (.element(let index), .separator(next: let limit), false),
|
||||
(.separator(next: let index), .separator(next: let limit), true):
|
||||
return base.index(index, offsetBy: -(distance / 2), limitedBy: limit)
|
||||
.map { .separator(next: $0) }
|
||||
|
||||
case let (.element(index), .element(limit), false),
|
||||
let (.separator(next: index), .element(limit), true):
|
||||
|
||||
case (.element(let index), .element(let limit), false),
|
||||
(.separator(next: let index), .element(let limit), true):
|
||||
return base.index(index, offsetBy: -(distance / 2), limitedBy: limit)
|
||||
.flatMap { $0 == limit ? nil : .separator(next: $0) }
|
||||
}
|
||||
@@ -257,34 +267,32 @@ extension InterspersedSequence: Collection where Base: Collection {
|
||||
}
|
||||
|
||||
extension InterspersedSequence: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
where Base: BidirectionalCollection {
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i != startIndex, "Can't move before startIndex")
|
||||
switch i.representation {
|
||||
case let .element(index):
|
||||
case .element(let index):
|
||||
return .separator(next: index)
|
||||
case let .separator(next):
|
||||
case .separator(let next):
|
||||
return .element(base.index(before: next))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension InterspersedSequence: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension InterspersedSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension InterspersedSequence: LazyCollectionProtocol
|
||||
where Base: LazySequenceProtocol & Collection {}
|
||||
where Base: LazySequenceProtocol & Collection {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// InterspersedMap
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
|
||||
/// A sequence over the results of applying a closure to the sequence's
|
||||
/// elements, with a separator that separates each pair of adjacent transformed
|
||||
/// values.
|
||||
@@ -292,10 +300,10 @@ extension InterspersedSequence: LazyCollectionProtocol
|
||||
internal struct InterspersedMapSequence<Base: Sequence, Result> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let transform: (Base.Element) -> Result
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let separator: (Base.Element, Base.Element) -> Result
|
||||
}
|
||||
@@ -309,19 +317,19 @@ extension InterspersedMapSequence: Sequence {
|
||||
case element(Base.Element)
|
||||
case separator(previous: Base.Element)
|
||||
}
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var base: Base.Iterator
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let transform: (Base.Element) -> Result
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let separator: (Base.Element, Base.Element) -> Result
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var state = State.start
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base.Iterator,
|
||||
@@ -368,61 +376,64 @@ extension InterspersedMapSequence: Collection where Base: Collection {
|
||||
case element(Base.Index)
|
||||
case separator(previous: Base.Index, next: Base.Index)
|
||||
}
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let representation: Representation
|
||||
|
||||
internal let base: Representation
|
||||
|
||||
@inlinable
|
||||
internal init(representation: Representation) {
|
||||
self.representation = representation
|
||||
self.base = representation
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal static func element(_ index: Base.Index) -> Self {
|
||||
Self(representation: .element(index))
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal static func separator(previous: Base.Index, next: Base.Index) -> Self {
|
||||
internal static func separator(
|
||||
previous: Base.Index,
|
||||
next: Base.Index
|
||||
) -> Self {
|
||||
Self(representation: .separator(previous: previous, next: next))
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
switch (lhs.representation, rhs.representation) {
|
||||
case let (.element(lhs), .element(rhs)),
|
||||
let (.separator(_, next: lhs), .separator(_, next: rhs)):
|
||||
switch (lhs.base, rhs.base) {
|
||||
case (.element(let lhs), .element(let rhs)),
|
||||
(.separator(_, next: let lhs), .separator(_, next: let rhs)):
|
||||
return lhs == rhs
|
||||
case (.element, .separator), (.separator, .element):
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
switch (lhs.representation, rhs.representation) {
|
||||
case let (.element(lhs), .element(rhs)),
|
||||
let (.separator(_, next: lhs), .separator(_, next: rhs)),
|
||||
let (.element(lhs), .separator(_, next: rhs)),
|
||||
let (.separator(previous: lhs, _), .element(rhs)):
|
||||
switch (lhs.base, rhs.base) {
|
||||
case (.element(let lhs), .element(let rhs)),
|
||||
(.separator(_, next: let lhs), .separator(_, next: let rhs)),
|
||||
(.element(let lhs), .separator(_, next: let rhs)),
|
||||
(.separator(previous: let lhs, _), .element(let rhs)):
|
||||
return lhs < rhs
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal var startIndex: Index {
|
||||
base.isEmpty ? endIndex : .element(base.startIndex)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal var endIndex: Index {
|
||||
.separator(previous: base.endIndex, next: base.endIndex)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func index(after index: Index) -> Index {
|
||||
switch index.representation {
|
||||
switch index.base {
|
||||
case .element(let index):
|
||||
let next = base.index(after: index)
|
||||
return .separator(previous: index, next: next)
|
||||
@@ -430,39 +441,39 @@ extension InterspersedMapSequence: Collection where Base: Collection {
|
||||
return .element(next)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal subscript(position: Index) -> Result {
|
||||
switch position.representation {
|
||||
switch position.base {
|
||||
case .element(let index):
|
||||
return transform(base[index])
|
||||
case let .separator(previous, next):
|
||||
case .separator(let previous, let next):
|
||||
return separator(base[previous], base[next])
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func distance(from start: Index, to end: Index) -> Int {
|
||||
switch (start.representation, end.representation) {
|
||||
case let (.element(lhs), .element(rhs)),
|
||||
let (.separator(_, next: lhs), .separator(_, next: rhs)):
|
||||
switch (start.base, end.base) {
|
||||
case (.element(let lhs), .element(let rhs)),
|
||||
(.separator(_, next: let lhs), .separator(_, next: let rhs)):
|
||||
return 2 * base.distance(from: lhs, to: rhs)
|
||||
case let (.element(lhs), .separator(_, next: rhs)):
|
||||
case (.element(let lhs), .separator(_, next: let rhs)):
|
||||
return 2 * base.distance(from: lhs, to: rhs) - 1
|
||||
case let (.separator(_, next: lhs), .element(rhs)):
|
||||
case (.separator(_, next: let lhs), .element(let rhs)):
|
||||
return 2 * base.distance(from: lhs, to: rhs) + 1
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func index(_ index: Index, offsetBy distance: Int) -> Index {
|
||||
guard distance != 0 else { return index }
|
||||
|
||||
|
||||
return distance > 0
|
||||
? offsetForward(index, by: distance)
|
||||
: offsetBackward(index, by: -distance)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func index(
|
||||
_ index: Index,
|
||||
@@ -470,7 +481,7 @@ extension InterspersedMapSequence: Collection where Base: Collection {
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
guard distance != 0 else { return index }
|
||||
|
||||
|
||||
if distance > 0 {
|
||||
return limit >= index
|
||||
? offsetForward(index, by: distance, limitedBy: limit)
|
||||
@@ -481,38 +492,40 @@ extension InterspersedMapSequence: Collection where Base: Collection {
|
||||
: offsetBackward(index, 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") }
|
||||
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") }
|
||||
return index
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(
|
||||
_ index: Index, by distance: Int, limitedBy limit: Index
|
||||
_ index: Index,
|
||||
by distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
assert(limit >= index)
|
||||
|
||||
switch (index.representation, limit.representation, distance.isMultiple(of: 2)) {
|
||||
case let (.element(index), .element(limit), true),
|
||||
let (.separator(_, next: index), .element(limit), false):
|
||||
|
||||
switch (index.base, limit.base, distance.isMultiple(of: 2)) {
|
||||
case (.element(let index), .element(let limit), true),
|
||||
(.separator(_, next: let index), .element(let limit), false):
|
||||
return base.index(index, offsetBy: distance / 2, limitedBy: limit)
|
||||
.map { .element($0) }
|
||||
|
||||
case let (.element(index), .element(limit), false),
|
||||
let (.element(index), .separator(_, next: limit), false),
|
||||
let (.separator(_, next: index), .element(limit), true),
|
||||
let (.separator(_, next: index), .separator(_, next: limit), true):
|
||||
|
||||
case (.element(let index), .element(let limit), false),
|
||||
(.element(let index), .separator(_, next: let limit), false),
|
||||
(.separator(_, next: let index), .element(let limit), true),
|
||||
(.separator(_, next: let index), .separator(_, next: let limit), true):
|
||||
return base.index(index, offsetBy: (distance - 1) / 2, limitedBy: limit)
|
||||
.flatMap {
|
||||
guard $0 != limit else { return nil }
|
||||
@@ -521,36 +534,40 @@ extension InterspersedMapSequence: Collection where Base: Collection {
|
||||
? endIndex
|
||||
: .separator(previous: $0, next: next)
|
||||
}
|
||||
|
||||
case let (.element(index), .separator(_, next: limit), true),
|
||||
let (.separator(_, next: index), .separator(_, next: limit), false):
|
||||
|
||||
case (.element(let index), .separator(_, next: let limit), true),
|
||||
(.separator(_, next: let index), .separator(_, next: let limit), false):
|
||||
return base.index(index, offsetBy: distance / 2, limitedBy: limit)
|
||||
.flatMap { $0 == limit ? nil : .element($0) }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ index: Index, by distance: Int, limitedBy limit: Index
|
||||
_ index: Index,
|
||||
by distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
assert(limit <= index)
|
||||
|
||||
switch (index.representation, limit.representation, distance.isMultiple(of: 2)) {
|
||||
case let (.element(index), .element(limit), true),
|
||||
let (.element(index), .separator(_, next: limit), true),
|
||||
let (.separator(_, next: index), .element(limit), false),
|
||||
let (.separator(_, next: index), .separator(_, next: limit), false):
|
||||
return base.index(index, offsetBy: -((distance + 1) / 2), limitedBy: limit)
|
||||
|
||||
switch (index.base, limit.base, distance.isMultiple(of: 2)) {
|
||||
case (.element(let index), .element(let limit), true),
|
||||
(.element(let index), .separator(_, next: let limit), true),
|
||||
(.separator(_, next: let index), .element(let limit), false),
|
||||
(.separator(_, next: let index), .separator(_, next: let limit), false):
|
||||
return
|
||||
base
|
||||
.index(index, offsetBy: -((distance + 1) / 2), limitedBy: limit)
|
||||
.map { .element($0) }
|
||||
|
||||
case let (.element(index), .separator(_, next: limit), false),
|
||||
let (.separator(_, next: index), .separator(_, next: limit), true):
|
||||
|
||||
case (.element(let index), .separator(_, next: let limit), false),
|
||||
(.separator(_, next: let index), .separator(_, next: let limit), true):
|
||||
return base.index(index, offsetBy: -(distance / 2), limitedBy: limit)
|
||||
.map { .separator(previous: base.index($0, offsetBy: -1), next: $0) }
|
||||
|
||||
case let (.element(index), .element(limit), false),
|
||||
let (.separator(_, next: index), .element(limit), true):
|
||||
|
||||
case (.element(let index), .element(let limit), false),
|
||||
(.separator(_, next: let index), .element(let limit), true):
|
||||
return base.index(index, offsetBy: -(distance / 2), limitedBy: limit)
|
||||
.flatMap {
|
||||
$0 == limit
|
||||
@@ -562,15 +579,14 @@ extension InterspersedMapSequence: Collection where Base: Collection {
|
||||
}
|
||||
|
||||
extension InterspersedMapSequence: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
where Base: BidirectionalCollection {
|
||||
@inlinable
|
||||
internal func index(before index: Index) -> Index {
|
||||
switch index.representation {
|
||||
switch index.base {
|
||||
case .element(let index):
|
||||
let previous = base.index(before: index)
|
||||
return .separator(previous: previous, next: index)
|
||||
case let .separator(previous, next):
|
||||
case .separator(let previous, let next):
|
||||
let index = next == base.endIndex ? base.index(before: next) : previous
|
||||
return .element(index)
|
||||
}
|
||||
@@ -578,11 +594,10 @@ extension InterspersedMapSequence: BidirectionalCollection
|
||||
}
|
||||
|
||||
extension InterspersedMapSequence.Index: Hashable
|
||||
where Base.Index: Hashable
|
||||
{
|
||||
where Base.Index: Hashable {
|
||||
@inlinable
|
||||
internal func hash(into hasher: inout Hasher) {
|
||||
switch representation {
|
||||
switch base {
|
||||
case .element(let base):
|
||||
hasher.combine(false)
|
||||
hasher.combine(base)
|
||||
@@ -595,7 +610,7 @@ extension InterspersedMapSequence.Index: Hashable
|
||||
|
||||
extension InterspersedMapSequence: LazySequenceProtocol {}
|
||||
extension InterspersedMapSequence: LazyCollectionProtocol
|
||||
where Base: Collection {}
|
||||
where Base: Collection {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// interspersed(with:)
|
||||
|
||||
@@ -16,15 +16,17 @@
|
||||
/// A sequence that presents the elements of a base sequence of sequences
|
||||
/// concatenated using a given separator.
|
||||
public struct JoinedBySequence<Base: Sequence, Separator: Sequence>
|
||||
where Base.Element: Sequence, Base.Element.Element == Separator.Element
|
||||
{
|
||||
where Base.Element: Sequence, Base.Element.Element == Separator.Element {
|
||||
@usableFromInline
|
||||
internal typealias Inner = FlattenSequence<InterspersedSequence<
|
||||
LazyMapSequence<Base, EitherSequence<Base.Element, Separator>>>>
|
||||
|
||||
internal typealias Inner = FlattenSequence<
|
||||
InterspersedSequence<
|
||||
LazyMapSequence<Base, EitherSequence<Base.Element, Separator>>
|
||||
>
|
||||
>
|
||||
|
||||
@usableFromInline
|
||||
internal let inner: Inner
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, separator: Separator) {
|
||||
self.inner = base.lazy
|
||||
@@ -38,18 +40,18 @@ extension JoinedBySequence: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var inner: Inner.Iterator
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(inner: Inner.Iterator) {
|
||||
self.inner = inner
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Base.Element.Element? {
|
||||
inner.next()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(inner: inner.makeIterator())
|
||||
@@ -57,7 +59,7 @@ extension JoinedBySequence: Sequence {
|
||||
}
|
||||
|
||||
extension JoinedBySequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// JoinedByClosureSequence
|
||||
@@ -67,15 +69,17 @@ extension JoinedBySequence: LazySequenceProtocol
|
||||
/// concatenated using a given separator that depends on the sequences right
|
||||
/// before and after it.
|
||||
public struct JoinedByClosureSequence<Base: Sequence, Separator: Sequence>
|
||||
where Base.Element: Sequence, Base.Element.Element == Separator.Element
|
||||
{
|
||||
where Base.Element: Sequence, Base.Element.Element == Separator.Element {
|
||||
@usableFromInline
|
||||
internal typealias Inner = FlattenSequence<InterspersedMapSequence<
|
||||
Base, EitherSequence<Base.Element, Separator>>>
|
||||
|
||||
internal typealias Inner = FlattenSequence<
|
||||
InterspersedMapSequence<
|
||||
Base, EitherSequence<Base.Element, Separator>
|
||||
>
|
||||
>
|
||||
|
||||
@usableFromInline
|
||||
internal let inner: Inner
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base,
|
||||
@@ -84,7 +88,8 @@ public struct JoinedByClosureSequence<Base: Sequence, Separator: Sequence>
|
||||
self.inner = base.lazy
|
||||
.interspersedMap(
|
||||
EitherSequence.left,
|
||||
with: { EitherSequence.right(separator($0, $1)) })
|
||||
with: { EitherSequence.right(separator($0, $1)) }
|
||||
)
|
||||
.joined()
|
||||
}
|
||||
}
|
||||
@@ -93,18 +98,18 @@ extension JoinedByClosureSequence: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var inner: Inner.Iterator
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(inner: Inner.Iterator) {
|
||||
self.inner = inner
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Base.Element.Element? {
|
||||
inner.next()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(inner: inner.makeIterator())
|
||||
@@ -120,15 +125,17 @@ extension JoinedByClosureSequence: LazySequenceProtocol {}
|
||||
/// A collection that presents the elements of a base collection of collections
|
||||
/// concatenated using a given separator.
|
||||
public struct JoinedByCollection<Base: Collection, Separator: Collection>
|
||||
where Base.Element: Collection, Base.Element.Element == Separator.Element
|
||||
{
|
||||
where Base.Element: Collection, Base.Element.Element == Separator.Element {
|
||||
@usableFromInline
|
||||
internal typealias Inner = FlattenCollection<InterspersedSequence<
|
||||
LazyMapSequence<Base, EitherSequence<Base.Element, Separator>>>>
|
||||
|
||||
internal typealias Inner = FlattenCollection<
|
||||
InterspersedSequence<
|
||||
LazyMapSequence<Base, EitherSequence<Base.Element, Separator>>
|
||||
>
|
||||
>
|
||||
|
||||
@usableFromInline
|
||||
internal let inner: Inner
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, separator: Separator) {
|
||||
self.inner = base.lazy
|
||||
@@ -142,48 +149,48 @@ extension JoinedByCollection: Collection {
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal let inner: Inner.Index
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(_ inner: Inner.Index) {
|
||||
self.inner = inner
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.inner == rhs.inner
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.inner < rhs.inner
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(inner.startIndex)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(inner.endIndex)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(after index: Index) -> Index {
|
||||
Index(inner.index(after: index.inner))
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> Base.Element.Element {
|
||||
inner[position.inner]
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(_ index: Index, offsetBy distance: Int) -> Index {
|
||||
Index(inner.index(index.inner, offsetBy: distance))
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ index: Index,
|
||||
@@ -193,7 +200,7 @@ extension JoinedByCollection: Collection {
|
||||
inner.index(index.inner, offsetBy: distance, limitedBy: limit.inner)
|
||||
.map(Index.init)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
inner.distance(from: start.inner, to: end.inner)
|
||||
@@ -201,9 +208,10 @@ extension JoinedByCollection: Collection {
|
||||
}
|
||||
|
||||
extension JoinedByCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection,
|
||||
Base.Element: BidirectionalCollection,
|
||||
Separator: BidirectionalCollection
|
||||
where
|
||||
Base: BidirectionalCollection,
|
||||
Base.Element: BidirectionalCollection,
|
||||
Separator: BidirectionalCollection
|
||||
{
|
||||
@inlinable
|
||||
public func index(before index: Index) -> Index {
|
||||
@@ -212,7 +220,7 @@ extension JoinedByCollection: BidirectionalCollection
|
||||
}
|
||||
|
||||
extension JoinedByCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// JoinedByClosureCollection
|
||||
@@ -222,15 +230,17 @@ extension JoinedByCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
/// concatenated using a given separator that depends on the collections right
|
||||
/// before and after it.
|
||||
public struct JoinedByClosureCollection<Base: Collection, Separator: Collection>
|
||||
where Base.Element: Collection, Base.Element.Element == Separator.Element
|
||||
{
|
||||
where Base.Element: Collection, Base.Element.Element == Separator.Element {
|
||||
@usableFromInline
|
||||
internal typealias Inner = FlattenCollection<InterspersedMapSequence<
|
||||
Base, EitherSequence<Base.Element, Separator>>>
|
||||
|
||||
internal typealias Inner = FlattenCollection<
|
||||
InterspersedMapSequence<
|
||||
Base, EitherSequence<Base.Element, Separator>
|
||||
>
|
||||
>
|
||||
|
||||
@usableFromInline
|
||||
internal let inner: Inner
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base,
|
||||
@@ -239,7 +249,8 @@ public struct JoinedByClosureCollection<Base: Collection, Separator: Collection>
|
||||
self.inner = base.lazy
|
||||
.interspersedMap(
|
||||
EitherSequence.left,
|
||||
with: { EitherSequence.right(separator($0, $1)) })
|
||||
with: { EitherSequence.right(separator($0, $1)) }
|
||||
)
|
||||
.joined()
|
||||
}
|
||||
}
|
||||
@@ -248,48 +259,48 @@ extension JoinedByClosureCollection: Collection {
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal let inner: Inner.Index
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(_ inner: Inner.Index) {
|
||||
self.inner = inner
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.inner == rhs.inner
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.inner < rhs.inner
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(inner.startIndex)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(inner.endIndex)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(after index: Index) -> Index {
|
||||
Index(inner.index(after: index.inner))
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> Base.Element.Element {
|
||||
inner[position.inner]
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(_ index: Index, offsetBy distance: Int) -> Index {
|
||||
Index(inner.index(index.inner, offsetBy: distance))
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ index: Index,
|
||||
@@ -299,7 +310,7 @@ extension JoinedByClosureCollection: Collection {
|
||||
inner.index(index.inner, offsetBy: distance, limitedBy: limit.inner)
|
||||
.map(Index.init)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
inner.distance(from: start.inner, to: end.inner)
|
||||
@@ -307,9 +318,10 @@ extension JoinedByClosureCollection: Collection {
|
||||
}
|
||||
|
||||
extension JoinedByClosureCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection,
|
||||
Base.Element: BidirectionalCollection,
|
||||
Separator: BidirectionalCollection
|
||||
where
|
||||
Base: BidirectionalCollection,
|
||||
Base.Element: BidirectionalCollection,
|
||||
Separator: BidirectionalCollection
|
||||
{
|
||||
@inlinable
|
||||
public func index(before index: Index) -> Index {
|
||||
@@ -337,7 +349,7 @@ extension Sequence where Element: Sequence {
|
||||
{
|
||||
joined(by: CollectionOfOne(separator))
|
||||
}
|
||||
|
||||
|
||||
/// Returns the concatenation of the elements in this sequence of sequences,
|
||||
/// inserting the given separator between each sequence.
|
||||
///
|
||||
@@ -349,30 +361,29 @@ extension Sequence where Element: Sequence {
|
||||
public func joined<Separator>(
|
||||
by separator: Separator
|
||||
) -> JoinedBySequence<Self, Separator>
|
||||
where Separator: Collection, Separator.Element == Element.Element
|
||||
{
|
||||
where Separator: Collection, Separator.Element == Element.Element {
|
||||
JoinedBySequence(base: self, separator: separator)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func _joined(
|
||||
by update: (inout [Element.Element], Element, Element) throws -> Void
|
||||
) rethrows -> [Element.Element] {
|
||||
var iterator = makeIterator()
|
||||
guard let first = iterator.next() else { return [] }
|
||||
|
||||
|
||||
var result = Array(first)
|
||||
var previous = first
|
||||
|
||||
|
||||
while let next = iterator.next() {
|
||||
try update(&result, previous, next)
|
||||
result.append(contentsOf: next)
|
||||
previous = next
|
||||
}
|
||||
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
|
||||
/// Returns the concatenation of the elements in this sequence of sequences,
|
||||
/// inserting the separator produced by the closure between each sequence.
|
||||
///
|
||||
@@ -386,7 +397,7 @@ extension Sequence where Element: Sequence {
|
||||
) rethrows -> [Element.Element] {
|
||||
try _joined(by: { $0.append(try separator($1, $2)) })
|
||||
}
|
||||
|
||||
|
||||
/// Returns the concatenation of the elements in this sequence of sequences,
|
||||
/// inserting the separator produced by the closure between each sequence.
|
||||
///
|
||||
@@ -398,8 +409,7 @@ extension Sequence where Element: Sequence {
|
||||
public func joined<Separator>(
|
||||
by separator: (Element, Element) throws -> Separator
|
||||
) rethrows -> [Element.Element]
|
||||
where Separator: Sequence, Separator.Element == Element.Element
|
||||
{
|
||||
where Separator: Sequence, Separator.Element == Element.Element {
|
||||
try _joined(by: { $0.append(contentsOf: try separator($1, $2)) })
|
||||
}
|
||||
}
|
||||
@@ -417,7 +427,7 @@ extension LazySequenceProtocol where Element: Sequence {
|
||||
) -> JoinedByClosureSequence<Elements, CollectionOfOne<Element.Element>> {
|
||||
joined(by: { CollectionOfOne(separator($0, $1)) })
|
||||
}
|
||||
|
||||
|
||||
/// Returns the concatenation of the elements in this sequence of sequences,
|
||||
/// inserting the separator produced by the closure between each sequence.
|
||||
@inlinable
|
||||
@@ -446,7 +456,7 @@ extension Collection where Element: Collection {
|
||||
{
|
||||
joined(by: CollectionOfOne(separator))
|
||||
}
|
||||
|
||||
|
||||
/// Returns the concatenation of the elements in this collection of
|
||||
/// collections, inserting the given separator between each collection.
|
||||
///
|
||||
@@ -476,7 +486,7 @@ extension LazySequenceProtocol where Elements: Collection, Element: Collection {
|
||||
) -> JoinedByClosureCollection<Elements, CollectionOfOne<Element.Element>> {
|
||||
joined(by: { CollectionOfOne(separator($0, $1)) })
|
||||
}
|
||||
|
||||
|
||||
/// Returns the concatenation of the elements in this collection of
|
||||
/// collections, inserting the separator produced by the closure between each
|
||||
/// sequence.
|
||||
|
||||
@@ -10,40 +10,51 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Sequence {
|
||||
/// Creates a new Dictionary from the elements of `self`, keyed by the
|
||||
/// results returned by the given `keyForValue` closure.
|
||||
/// Creates a new dictionary keyed by the result of the given closure, using
|
||||
/// the latest element for any duplicate keys.
|
||||
///
|
||||
/// If the key derived for a new element collides with an existing key from a previous element,
|
||||
/// the latest value will be kept.
|
||||
/// If the key derived for a new element collides with an existing key from a
|
||||
/// previous element, the latest value will be kept.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - keyForValue: A closure that returns a key for each element in `self`.
|
||||
/// - Parameter keyForValue: A closure that returns a key for each element in
|
||||
/// `self`.
|
||||
/// - Returns: A dictionary with key-value pairs generated by calling
|
||||
/// `keyForValue` for each element in this sequence. If `keyForValue`
|
||||
/// returns the same key for two or more elements, the returned dictionary
|
||||
/// uses the last value for that key.
|
||||
@inlinable
|
||||
public func keyed<Key>(
|
||||
by keyForValue: (Element) throws -> Key
|
||||
) rethrows -> [Key: Element] {
|
||||
return try self.keyed(by: keyForValue, resolvingConflictsWith: { _, old, new in new })
|
||||
try self.reduce(into: [:]) { result, element in
|
||||
try result[keyForValue(element)] = element
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates a new Dictionary from the elements of `self`, keyed by the
|
||||
/// results returned by the given `keyForValue` closure. As the dictionary is
|
||||
/// built, the initializer calls the `resolve` closure with the current and
|
||||
/// new values for any duplicate keys. Pass a closure as `resolve` that
|
||||
/// returns the value to use in the resulting dictionary: The closure can
|
||||
/// choose between the two values, combine them to produce a new value, or
|
||||
/// even throw an error.
|
||||
/// Creates a new dictionary keyed by the result of the first closure, using
|
||||
/// the second closure to resolve the ambiguity for any duplicate keys.
|
||||
///
|
||||
/// As the dictionary is built, the initializer calls the `resolve` closure
|
||||
/// with the current and new values for any duplicate keys. Pass a closure as
|
||||
/// `resolve` that returns the value to use for that key in the resulting
|
||||
/// dictionary. The closure can choose between the two values, combine them to
|
||||
/// produce a new value, or even throw an error.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - keyForValue: A closure that returns a key for each element in `self`.
|
||||
/// - resolve: A closure that is called with the values for any duplicate
|
||||
/// keys that are encountered. The closure returns the desired value for
|
||||
/// the final dictionary.
|
||||
/// - Returns: A dictionary with key-value pairs generated by calling
|
||||
/// `keyForValue` for each element in this sequence. If `keyForValue`
|
||||
/// returns the same key for two or more elements, the result of the
|
||||
/// `resolve` closure is used as the value for that key.
|
||||
@inlinable
|
||||
public func keyed<Key>(
|
||||
by keyForValue: (Element) throws -> Key,
|
||||
resolvingConflictsWith resolve: (Key, Element, Element) throws -> Element
|
||||
) rethrows -> [Key: Element] {
|
||||
var result = [Key: Element]()
|
||||
var result: [Key: Element] = [:]
|
||||
|
||||
for element in self {
|
||||
let key = try keyForValue(element)
|
||||
|
||||
@@ -10,24 +10,24 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Sequence {
|
||||
/// Implementation for min(count:areInIncreasingOrder:)
|
||||
// Implementation for min(count:areInIncreasingOrder:)
|
||||
@inlinable
|
||||
internal func _minImplementation(
|
||||
count: Int,
|
||||
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 }
|
||||
// To be part of `result`, `e` must be strictly less than `result[count - 1]`.
|
||||
guard try areInIncreasingOrder(e, result[count - 1]) else { continue }
|
||||
result.removeLast()
|
||||
let insertionIndex =
|
||||
try result.partitioningIndex { try areInIncreasingOrder(e, $0) }
|
||||
@@ -36,25 +36,25 @@ extension Sequence {
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
/// Implementation for max(count:areInIncreasingOrder:)
|
||||
|
||||
// Implementation for max(count:areInIncreasingOrder:)
|
||||
@inlinable
|
||||
internal func _maxImplementation(
|
||||
count: Int,
|
||||
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 }
|
||||
// To be part of `result`, `e` must be greater/equal to `result[0]`.
|
||||
guard try !areInIncreasingOrder(e, result[0]) else { continue }
|
||||
let insertionIndex =
|
||||
try result.partitioningIndex { try areInIncreasingOrder(e, $0) }
|
||||
|
||||
@@ -69,10 +69,10 @@ extension Sequence {
|
||||
}
|
||||
result[insertionIndex - 1] = e
|
||||
}
|
||||
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
|
||||
/// Returns the smallest elements of this sequence, as sorted by the given
|
||||
/// predicate.
|
||||
///
|
||||
@@ -105,7 +105,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!
|
||||
"""
|
||||
)
|
||||
@@ -150,7 +152,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!
|
||||
"""
|
||||
)
|
||||
@@ -251,14 +255,16 @@ 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!
|
||||
"""
|
||||
)
|
||||
|
||||
// Make sure we are within bounds.
|
||||
let prefixCount = Swift.min(count, self.count)
|
||||
|
||||
|
||||
// Do nothing if we're prefixing nothing.
|
||||
guard prefixCount > 0 else {
|
||||
return []
|
||||
@@ -269,7 +275,7 @@ extension Collection {
|
||||
guard prefixCount < (self.count / 10) else {
|
||||
return Array(try sorted(by: areInIncreasingOrder).prefix(prefixCount))
|
||||
}
|
||||
|
||||
|
||||
return try _minImplementation(count: count, sortedBy: areInIncreasingOrder)
|
||||
}
|
||||
|
||||
@@ -305,14 +311,16 @@ 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!
|
||||
"""
|
||||
)
|
||||
|
||||
// Make sure we are within bounds.
|
||||
let suffixCount = Swift.min(count, self.count)
|
||||
|
||||
|
||||
// Do nothing if we're suffixing nothing.
|
||||
guard suffixCount > 0 else {
|
||||
return []
|
||||
|
||||
@@ -1,539 +0,0 @@
|
||||
|
||||
extension Int {
|
||||
@inlinable
|
||||
internal var _log2: Int {
|
||||
Self.bitWidth - leadingZeroBitCount
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable internal var _partialInsertionSortSwapLimit: Int { 8 }
|
||||
|
||||
@inlinable internal var _insertionSortMaxCount: Int {
|
||||
#if INSERTION_MAX_32
|
||||
32
|
||||
#else
|
||||
20
|
||||
#endif
|
||||
}
|
||||
|
||||
@inlinable internal var _medianOfMediansMinCount: Int { 200 }
|
||||
|
||||
extension MutableCollection where Self: BidirectionalCollection {
|
||||
@inlinable
|
||||
internal mutating func _partialInsertionSort(
|
||||
within range: Range<Index>,
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> Bool {
|
||||
if range.isEmpty {
|
||||
return true
|
||||
}
|
||||
|
||||
var sortedEnd = index(after: range.lowerBound)
|
||||
var swaps = 0
|
||||
|
||||
// Continue sorting until the sorted elements cover the whole sequence.
|
||||
while sortedEnd != range.upperBound {
|
||||
var i = sortedEnd
|
||||
// Look backwards for `self[i]`'s position in the sorted sequence,
|
||||
// moving each element forward to make room.
|
||||
repeat {
|
||||
let j = index(before: i)
|
||||
|
||||
// If `self[i]` doesn't belong before `self[j]`, we've found
|
||||
// its position.
|
||||
if try !areInIncreasingOrder(self[i], self[j]) {
|
||||
break
|
||||
}
|
||||
|
||||
swapAt(i, j)
|
||||
i = j
|
||||
|
||||
// Quit if we've completed more than the swap limit.
|
||||
swaps += 1
|
||||
if swaps > _partialInsertionSortSwapLimit { return false }
|
||||
} while i != range.lowerBound
|
||||
|
||||
formIndex(after: &sortedEnd)
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
/// Sorts `self[range]` according to `areInIncreasingOrder`. Stable.
|
||||
///
|
||||
/// - Precondition: `sortedEnd != range.lowerBound`
|
||||
/// - Precondition: `elements[..<sortedEnd]` are already in order.
|
||||
@inlinable
|
||||
public
|
||||
mutating func _insertionSort(
|
||||
within range: Range<Index>,
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows {
|
||||
if range.isEmpty {
|
||||
return
|
||||
}
|
||||
var sortedEnd = index(after: range.lowerBound)
|
||||
|
||||
// Continue sorting until the sorted elements cover the whole sequence.
|
||||
while sortedEnd != range.upperBound {
|
||||
var i = sortedEnd
|
||||
#if INSERTION_TEMP
|
||||
let temp = self[i]
|
||||
#endif
|
||||
// Look backwards for `self[i]`'s position in the sorted sequence,
|
||||
// moving each element forward to make room.
|
||||
repeat {
|
||||
let j = index(before: i)
|
||||
|
||||
// If `self[i]` doesn't belong before `self[j]`, we've found
|
||||
// its position.
|
||||
#if INSERTION_TEMP
|
||||
if try !areInIncreasingOrder(temp, self[j]) {
|
||||
break
|
||||
}
|
||||
self[j] = self[i]
|
||||
#else
|
||||
if try !areInIncreasingOrder(self[i], self[j]) {
|
||||
break
|
||||
}
|
||||
swapAt(i, j)
|
||||
#endif
|
||||
|
||||
i = j
|
||||
} while i != range.lowerBound
|
||||
#if INSERTION_TEMP
|
||||
self[i] = temp
|
||||
#endif
|
||||
|
||||
formIndex(after: &sortedEnd)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal mutating func _sort2(
|
||||
_ a: Index, _ b: Index,
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows {
|
||||
if try areInIncreasingOrder(self[b], self[a]) {
|
||||
swapAt(a, b)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal mutating func _sort3a(
|
||||
_ a: Index, _ b: Index, _ c: Index,
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows {
|
||||
try _sort2(a, b, by: areInIncreasingOrder)
|
||||
try _sort2(b, c, by: areInIncreasingOrder)
|
||||
try _sort2(a, b, by: areInIncreasingOrder)
|
||||
}
|
||||
|
||||
/// Sorts the elements at `elements[a]`, `elements[b]`, and `elements[c]` to
|
||||
/// match the relative order of `a`, `b`, and `c`.
|
||||
@inlinable
|
||||
internal mutating func _sort3(
|
||||
_ a: Index, _ b: Index, _ c: Index,
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows {
|
||||
// There are thirteen possible permutations for the original ordering of
|
||||
// the elements at indices `a`, `b`, and `c`. The comments in the code below
|
||||
// show the relative ordering of the three elements using a three-digit
|
||||
// number as shorthand for the position and comparative relationship of
|
||||
// each element. For example, "312" indicates that the element at `a` is the
|
||||
// largest of the three, the element at `b` is the smallest, and the element
|
||||
// at `c` is the median. This hypothetical input array has a 312 ordering for
|
||||
// `a`, `b`, and `c`:
|
||||
//
|
||||
// [ 7, 4, 3, 9, 2, 0, 3, 7, 6, 5 ]
|
||||
// ^ ^ ^
|
||||
// a b c
|
||||
//
|
||||
// - If each of the three elements is distinct, they could be ordered as any
|
||||
// of the permutations of 1, 2, and 3: 123, 132, 213, 231, 312, or 321.
|
||||
// - If two elements are equivalent and one is distinct, they could be
|
||||
// ordered as any permutation of 1, 1, and 2 or 1, 2, and 2: 112, 121, 211,
|
||||
// 122, 212, or 221.
|
||||
// - If all three elements are equivalent, they are already in order: 111.
|
||||
|
||||
switch try (areInIncreasingOrder(self[b], self[a]),
|
||||
areInIncreasingOrder(self[c], self[b])) {
|
||||
case (false, false):
|
||||
// 0 swaps: 123, 112, 122, 111
|
||||
break
|
||||
|
||||
case (true, true):
|
||||
// 1 swap: 321
|
||||
// swap(a, c): 312->123
|
||||
swapAt(a, c)
|
||||
|
||||
case (true, false):
|
||||
// 1 swap: 213, 212 --- 2 swaps: 312, 211
|
||||
// swap(a, b): 213->123, 212->122, 312->132, 211->121
|
||||
swapAt(a, b)
|
||||
|
||||
if try areInIncreasingOrder(self[c], self[b]) {
|
||||
// 132 (started as 312), 121 (started as 211)
|
||||
// swap(b, c): 132->123, 121->112
|
||||
swapAt(b, c)
|
||||
}
|
||||
|
||||
case (false, true):
|
||||
// 1 swap: 132, 121 --- 2 swaps: 231, 221
|
||||
// swap(b, c): 132->123, 121->112, 231->213, 221->212
|
||||
swapAt(b, c)
|
||||
|
||||
if try areInIncreasingOrder(self[b], self[a]) {
|
||||
// 213 (started as 231), 212 (started as 221)
|
||||
// swap(a, b): 213->123, 212->122
|
||||
swapAt(a, b)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension MutableCollection where Self: RandomAccessCollection {
|
||||
@inlinable
|
||||
internal mutating func _siftDown(
|
||||
_ idx: Index,
|
||||
within range: Range<Index>,
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows {
|
||||
var idx = idx
|
||||
var countToIndex = distance(from: range.lowerBound, to: idx)
|
||||
var countFromIndex = distance(from: idx, to: range.upperBound)
|
||||
// Check if left child is within bounds. If not, stop iterating, because
|
||||
// there are no children of the given node in the heap.
|
||||
while countToIndex + 1 < countFromIndex {
|
||||
let left = index(idx, offsetBy: countToIndex + 1)
|
||||
var largest = idx
|
||||
if try areInIncreasingOrder(self[largest], self[left]) {
|
||||
largest = left
|
||||
}
|
||||
// Check if right child is also within bounds before trying to examine it.
|
||||
if countToIndex + 2 < countFromIndex {
|
||||
let right = index(after: left)
|
||||
if try areInIncreasingOrder(self[largest], self[right]) {
|
||||
largest = right
|
||||
}
|
||||
}
|
||||
// If a child is bigger than the current node, swap them and continue
|
||||
// sifting down.
|
||||
if largest != idx {
|
||||
swapAt(idx, largest)
|
||||
idx = largest
|
||||
countToIndex = distance(from: range.lowerBound, to: idx)
|
||||
countFromIndex = distance(from: idx, to: range.upperBound)
|
||||
} else {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal mutating func _heapify(
|
||||
within range: Range<Index>,
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows {
|
||||
// Here we build a heap starting from the lowest nodes and moving to the
|
||||
// root. On every step we sift down the current node to obey the max-heap
|
||||
// property:
|
||||
// parent >= max(leftChild, rightChild)
|
||||
//
|
||||
// We skip the rightmost half of the array, because these nodes don't have
|
||||
// any children.
|
||||
let root = range.lowerBound
|
||||
let half = distance(from: range.lowerBound, to: range.upperBound) / 2
|
||||
var node = index(root, offsetBy: half)
|
||||
|
||||
while node != root {
|
||||
formIndex(before: &node)
|
||||
try _siftDown(node, within: range, by: areInIncreasingOrder)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal mutating func _heapSort(
|
||||
within range: Range<Index>,
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows {
|
||||
var hi = range.upperBound
|
||||
let lo = range.lowerBound
|
||||
try _heapify(within: range, by: areInIncreasingOrder)
|
||||
formIndex(before: &hi)
|
||||
while hi != lo {
|
||||
swapAt(lo, hi)
|
||||
try _siftDown(lo, within: lo..<hi, by: areInIncreasingOrder)
|
||||
formIndex(before: &hi)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension MutableCollection where Self: BidirectionalCollection {
|
||||
@inlinable
|
||||
public // testing
|
||||
mutating func _partitionLeft(
|
||||
subrange: Range<Index>,
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> Index {
|
||||
assert(distance(from: subrange.lowerBound, to: subrange.upperBound) >= 2)
|
||||
|
||||
var (low, high) = (subrange.lowerBound, subrange.upperBound)
|
||||
let pivot = self[subrange.lowerBound]
|
||||
|
||||
// Search from end for last element equal to or less than pivot.
|
||||
repeat {
|
||||
formIndex(before: &high)
|
||||
// Don't need a separate `high > low` check, since self[low] == pivot,
|
||||
// which is a terminating condition based on comparison above.
|
||||
} while try areInIncreasingOrder(pivot, self[high])
|
||||
|
||||
// Search from beginning for first element greater than pivot.
|
||||
if high == index(before: subrange.upperBound) {
|
||||
while low < high {
|
||||
formIndex(after: &low)
|
||||
guard try !areInIncreasingOrder(pivot, self[low]) else {
|
||||
break
|
||||
}
|
||||
}
|
||||
} else {
|
||||
repeat {
|
||||
formIndex(after: &low)
|
||||
} while try !areInIncreasingOrder(pivot, self[low])
|
||||
}
|
||||
|
||||
// Swap remaining elements as needed.
|
||||
while low < high {
|
||||
swapAt(low, high)
|
||||
repeat {
|
||||
formIndex(before: &high)
|
||||
} while try areInIncreasingOrder(pivot, self[high])
|
||||
repeat {
|
||||
formIndex(after: &low)
|
||||
} while try !areInIncreasingOrder(pivot, self[low])
|
||||
}
|
||||
|
||||
// Move pivot to end of lower partition and return its position.
|
||||
swapAt(subrange.lowerBound, high)
|
||||
return high
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public // testing
|
||||
mutating func _partitionRight(
|
||||
subrange: Range<Index>,
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> (Index, alreadyPartitioned: Bool) {
|
||||
assert(distance(from: subrange.lowerBound, to: subrange.upperBound) >= 2)
|
||||
|
||||
var (low, high) = (subrange.lowerBound, subrange.upperBound)
|
||||
let pivot = self[subrange.lowerBound]
|
||||
|
||||
// Search from start for first element greater than or equal to pivot.
|
||||
repeat {
|
||||
formIndex(after: &low)
|
||||
} while try areInIncreasingOrder(self[low], pivot)
|
||||
|
||||
// Search from end for last element less than pivot.
|
||||
if low == index(after: subrange.lowerBound) {
|
||||
while low < high {
|
||||
formIndex(before: &high)
|
||||
guard try !areInIncreasingOrder(self[high], pivot) else {
|
||||
break
|
||||
}
|
||||
}
|
||||
} else {
|
||||
repeat {
|
||||
formIndex(before: &high)
|
||||
} while try !areInIncreasingOrder(self[high], pivot)
|
||||
}
|
||||
|
||||
let noSwapsRequired = low >= high
|
||||
|
||||
// Swap remaining elements as needed.
|
||||
while low < high {
|
||||
swapAt(low, high)
|
||||
repeat {
|
||||
formIndex(after: &low)
|
||||
} while try areInIncreasingOrder(self[low], pivot)
|
||||
repeat {
|
||||
formIndex(before: &high)
|
||||
} while try !areInIncreasingOrder(self[high], pivot)
|
||||
}
|
||||
|
||||
// Move pivot to start of upper partition and return its position.
|
||||
let result = index(before: low)
|
||||
swapAt(subrange.lowerBound, result)
|
||||
return (result, noSwapsRequired)
|
||||
}
|
||||
}
|
||||
|
||||
extension MutableCollection where Self: RandomAccessCollection {
|
||||
@inlinable
|
||||
public // testing
|
||||
mutating func _preparePivot(
|
||||
subrange: Range<Index>,
|
||||
count: Int,
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows {
|
||||
let low = subrange.lowerBound
|
||||
let high = index(before: subrange.upperBound)
|
||||
let mid = index(low, offsetBy: count / 2)
|
||||
|
||||
if count > _medianOfMediansMinCount {
|
||||
// Sort three "letter groups" of elements:
|
||||
// [A1, B1, C1, ..., A2, B2, C2, ..., C3, B3, A3]
|
||||
let low2 = index(after: low)
|
||||
let high2 = index(before: high)
|
||||
let midLo = index(before: mid)
|
||||
let midHi = index(after: mid)
|
||||
try _sort3(low, midLo, high, by: areInIncreasingOrder)
|
||||
try _sort3(low2, mid, high2, by: areInIncreasingOrder)
|
||||
try _sort3(
|
||||
index(after: low2), midHi, index(before: high2),
|
||||
by: areInIncreasingOrder)
|
||||
// After sorting, each lettered group of elements is sorted, so the
|
||||
// middle three elements are the three medians. Sort those three.
|
||||
try _sort3(midLo, mid, midHi, by: areInIncreasingOrder)
|
||||
|
||||
// The median of medians is the pivot; move it to the front.
|
||||
swapAt(low, mid)
|
||||
} else {
|
||||
// Note the order of index parameters; the smallest element will be at `mid`,
|
||||
// the middle element at `low`, and the largest element at `high`:
|
||||
try _sort3(mid, low, high, by: areInIncreasingOrder)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal mutating func _shuffleElements(subrange: Range<Index>, count: Int) {
|
||||
guard count > _insertionSortMaxCount else { return }
|
||||
|
||||
var low = subrange.lowerBound
|
||||
var lowQuarter = index(low, offsetBy: count / 4)
|
||||
var high = index(before: subrange.upperBound)
|
||||
var highQuarter = index(high, offsetBy: -count / 4)
|
||||
swapAt(low, lowQuarter)
|
||||
swapAt(high, highQuarter)
|
||||
|
||||
if count > _insertionSortMaxCount {
|
||||
for _ in 0..<2 {
|
||||
formIndex(after: &low)
|
||||
formIndex(before: &lowQuarter)
|
||||
formIndex(before: &high)
|
||||
formIndex(after: &highQuarter)
|
||||
swapAt(low, lowQuarter)
|
||||
swapAt(high, highQuarter)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal mutating func _pdqSortImpl(
|
||||
subrange: Range<Index>,
|
||||
count: Int,
|
||||
isLeftmost: Bool,
|
||||
remainingBadPartitions: Int,
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows {
|
||||
guard count > _insertionSortMaxCount else {
|
||||
try _insertionSort(within: subrange, by: areInIncreasingOrder)
|
||||
return
|
||||
}
|
||||
|
||||
try _preparePivot(subrange: subrange, count: count, by: areInIncreasingOrder)
|
||||
|
||||
if !isLeftmost {
|
||||
let predecessor = index(before: subrange.lowerBound)
|
||||
if try !areInIncreasingOrder(self[predecessor], self[subrange.lowerBound]) {
|
||||
let newLow = try _partitionLeft(subrange: subrange, by: areInIncreasingOrder)
|
||||
try _pdqSortImpl(
|
||||
subrange: newLow..<subrange.upperBound,
|
||||
count: distance(from: newLow, to: subrange.upperBound),
|
||||
isLeftmost: false,
|
||||
remainingBadPartitions: remainingBadPartitions,
|
||||
by: areInIncreasingOrder)
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
let (pivot, alreadyPartitioned) = try _partitionRight(
|
||||
subrange: subrange, by: areInIncreasingOrder)
|
||||
|
||||
let startOfUpper = index(after: pivot)
|
||||
let lowerCount = distance(from: subrange.lowerBound, to: pivot)
|
||||
let upperCount = count - lowerCount - 1
|
||||
let minPartitionSize = count / 8
|
||||
let isBadPartition = lowerCount < minPartitionSize || upperCount < minPartitionSize
|
||||
|
||||
var remainingBadPartitions = remainingBadPartitions
|
||||
if isBadPartition {
|
||||
// If we've had too many bad partitions, fall back to heap sort.
|
||||
remainingBadPartitions -= 1
|
||||
guard remainingBadPartitions > 0 else {
|
||||
try _heapSort(within: subrange, by: areInIncreasingOrder)
|
||||
return
|
||||
}
|
||||
|
||||
// Try shuffling elements within the partition to decrease chance of poor
|
||||
// pivot selection.
|
||||
_shuffleElements(subrange: subrange.lowerBound..<pivot, count: lowerCount)
|
||||
_shuffleElements(subrange: startOfUpper..<subrange.upperBound, count: upperCount)
|
||||
} else {
|
||||
// If there were no swaps required, use insertion sort to scan for already
|
||||
// sorted partitions, including some minor fix-ups.
|
||||
if alreadyPartitioned {
|
||||
if try _partialInsertionSort(within: subrange.lowerBound..<pivot, by: areInIncreasingOrder)
|
||||
&& _partialInsertionSort(within: startOfUpper..<subrange.upperBound, by: areInIncreasingOrder) {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
try _pdqSortImpl(
|
||||
subrange: subrange.lowerBound..<pivot,
|
||||
count: lowerCount,
|
||||
isLeftmost: isLeftmost,
|
||||
remainingBadPartitions: remainingBadPartitions,
|
||||
by: areInIncreasingOrder)
|
||||
try _pdqSortImpl(
|
||||
subrange: startOfUpper..<subrange.upperBound,
|
||||
count: upperCount,
|
||||
isLeftmost: false,
|
||||
remainingBadPartitions: remainingBadPartitions,
|
||||
by: areInIncreasingOrder)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func sortUnstable(
|
||||
subrange: Range<Index>,
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows {
|
||||
let count = distance(from: subrange.lowerBound, to: subrange.upperBound)
|
||||
try _pdqSortImpl(
|
||||
subrange: subrange,
|
||||
count: count,
|
||||
isLeftmost: true,
|
||||
remainingBadPartitions: count._log2,
|
||||
by: areInIncreasingOrder)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func sortUnstable(
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows {
|
||||
try sortUnstable(subrange: startIndex..<endIndex, by: areInIncreasingOrder)
|
||||
}
|
||||
}
|
||||
|
||||
extension MutableCollection where Self: RandomAccessCollection, Element: Comparable {
|
||||
@inlinable
|
||||
public mutating func sortUnstable(subrange: Range<Index>) {
|
||||
sortUnstable(subrange: subrange, by: <)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func sortUnstable() {
|
||||
sortUnstable(by: <)
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
@@ -55,19 +56,23 @@ extension MutableCollection {
|
||||
/// - belongsInSecondPartition: A predicate used to partition the
|
||||
/// collection. All elements satisfying this predicate are ordered after
|
||||
/// all elements not satisfying it.
|
||||
/// - Returns: The pivot index `p`, which is the index of the first element
|
||||
/// in the reordered collection that matches `belongsInSecondPartition`.
|
||||
/// If no elements in the collection match `belongsInSecondPartition`, the
|
||||
/// returned index is equal to the collection's `endIndex`.
|
||||
///
|
||||
/// - Complexity: O(*n* log *n*), where *n* is the length of this collection.
|
||||
@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.
|
||||
@@ -75,11 +80,15 @@ extension MutableCollection {
|
||||
/// - Parameter belongsInSecondPartition: A predicate used to partition the
|
||||
/// collection. All elements satisfying this predicate are ordered after
|
||||
/// all elements not satisfying it.
|
||||
/// - Returns: The pivot index `p`, which is the index of the first element
|
||||
/// in the reordered collection that matches `belongsInSecondPartition`.
|
||||
/// If no elements in the collection match `belongsInSecondPartition`, the
|
||||
/// returned index is equal to the collection's `endIndex`.
|
||||
///
|
||||
/// - 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,
|
||||
@@ -92,9 +101,25 @@ extension MutableCollection {
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension MutableCollection {
|
||||
/// Moves all elements satisfying `isSuffixElement` into a suffix of the
|
||||
/// Moves all elements satisfying the given closure into a suffix of the
|
||||
/// collection, returning the start position of the resulting suffix.
|
||||
///
|
||||
/// After partitioning a collection, there is a pivot index `p` where no
|
||||
/// element before `p` satisfies the `belongsInSecondPartition` predicate and
|
||||
/// every element at or after `p` satisfies `belongsInSecondPartition`. This
|
||||
/// operation isn't guaranteed to be stable, so the relative ordering of
|
||||
/// elements within the partitions might change.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - subrange: The range of elements within this collection to partition.
|
||||
/// - belongsInSecondPartition: A predicate used to partition the
|
||||
/// collection. All elements satisfying this predicate are ordered after
|
||||
/// all elements not satisfying it.
|
||||
/// - Returns: The pivot index `p`, which is the index of the first element
|
||||
/// in the reordered collection that matches `belongsInSecondPartition`.
|
||||
/// If no elements in the collection match `belongsInSecondPartition`, the
|
||||
/// returned index is equal to the collection's `endIndex`.
|
||||
///
|
||||
/// - Complexity: O(*n*) where n is the length of the collection.
|
||||
@inlinable
|
||||
public mutating func partition(
|
||||
@@ -104,8 +129,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,15 +139,31 @@ extension MutableCollection {
|
||||
}
|
||||
formIndex(after: &j)
|
||||
}
|
||||
|
||||
|
||||
return i
|
||||
}
|
||||
}
|
||||
|
||||
extension MutableCollection where Self: BidirectionalCollection {
|
||||
/// Moves all elements satisfying `isSuffixElement` into a suffix of the
|
||||
/// Moves all elements satisfying the given closure into a suffix of the
|
||||
/// collection, returning the start position of the resulting suffix.
|
||||
///
|
||||
/// After partitioning a collection, there is a pivot index `p` where no
|
||||
/// element before `p` satisfies the `belongsInSecondPartition` predicate and
|
||||
/// every element at or after `p` satisfies `belongsInSecondPartition`. This
|
||||
/// operation isn't guaranteed to be stable, so the relative ordering of
|
||||
/// elements within the partitions might change.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - subrange: The range of elements within this collection to partition.
|
||||
/// - belongsInSecondPartition: A predicate used to partition the
|
||||
/// collection. All elements satisfying this predicate are ordered after
|
||||
/// all elements not satisfying it.
|
||||
/// - Returns: The pivot index `p`, which is the index of the first element
|
||||
/// in the reordered collection that matches `belongsInSecondPartition`.
|
||||
/// If no elements in the collection match `belongsInSecondPartition`, the
|
||||
/// returned index is equal to the collection's `endIndex`.
|
||||
///
|
||||
/// - Complexity: O(*n*) where n is the length of the collection.
|
||||
@inlinable
|
||||
public mutating func partition(
|
||||
@@ -190,7 +231,7 @@ extension Collection {
|
||||
) rethrows -> Index {
|
||||
var n = count
|
||||
var l = startIndex
|
||||
|
||||
|
||||
while n > 0 {
|
||||
let half = n / 2
|
||||
let mid = index(l, offsetBy: half)
|
||||
@@ -224,24 +265,23 @@ extension Sequence {
|
||||
/// // Prints "["Kim", "Karl"]"
|
||||
///
|
||||
/// - Parameter predicate: A closure that takes an element of the sequence as
|
||||
/// its argument and returns a Boolean value indicating whether the element
|
||||
/// should be included in the second returned array. Otherwise, the element
|
||||
/// will appear in the first returned array.
|
||||
///
|
||||
/// its argument and returns a Boolean value indicating whether the element
|
||||
/// should be included in the second returned array. Otherwise, the element
|
||||
/// will appear in the first returned array.
|
||||
/// - Returns: Two arrays with all of the elements of the receiver. The
|
||||
/// first array contains all the elements that `predicate` didn’t allow, and
|
||||
/// the second array contains all the elements that `predicate` allowed. The
|
||||
/// order of the elements in the arrays matches the order of the elements in
|
||||
/// the original sequence.
|
||||
/// first array contains all the elements that `predicate` didn’t allow, and
|
||||
/// the second array contains all the elements that `predicate` allowed. The
|
||||
/// order of the elements in the arrays matches the order of the elements in
|
||||
/// the original sequence.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the sequence.
|
||||
@inlinable
|
||||
public func partitioned(
|
||||
by predicate: (Element) throws -> Bool
|
||||
) rethrows -> (falseElements: [Element], trueElements: [Element]) {
|
||||
var lhs = [Element]()
|
||||
var rhs = [Element]()
|
||||
|
||||
var lhs: [Element] = []
|
||||
var rhs: [Element] = []
|
||||
|
||||
for element in self {
|
||||
if try predicate(element) {
|
||||
rhs.append(element)
|
||||
@@ -249,7 +289,7 @@ extension Sequence {
|
||||
lhs.append(element)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return (lhs, rhs)
|
||||
}
|
||||
}
|
||||
@@ -269,15 +309,14 @@ extension Collection {
|
||||
/// // Prints "["Kim", "Karl"]"
|
||||
///
|
||||
/// - Parameter predicate: A closure that takes an element of the collection
|
||||
/// as its argument and returns a Boolean value indicating whether the element
|
||||
/// should be included in the second returned array. Otherwise, the element
|
||||
/// will appear in the first returned array.
|
||||
///
|
||||
/// as its argument and returns a Boolean value indicating whether the
|
||||
/// element should be included in the second returned array. Otherwise, the
|
||||
/// element will appear in the first returned array.
|
||||
/// - Returns: Two arrays with all of the elements of the receiver. The
|
||||
/// first array contains all the elements that `predicate` didn’t allow, and
|
||||
/// the second array contains all the elements that `predicate` allowed. The
|
||||
/// order of the elements in the arrays matches the order of the elements in
|
||||
/// the original collection.
|
||||
/// first array contains all the elements that `predicate` didn’t allow, and
|
||||
/// the second array contains all the elements that `predicate` allowed. The
|
||||
/// order of the elements in the arrays matches the order of the elements in
|
||||
/// the original collection.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@inlinable
|
||||
@@ -287,23 +326,26 @@ extension Collection {
|
||||
guard !self.isEmpty else {
|
||||
return ([], [])
|
||||
}
|
||||
|
||||
|
||||
// Since collections have known sizes, we can allocate one array of size
|
||||
// `self.count`, then insert items at the beginning or end of that contiguous
|
||||
// block. This way, we don’t have to do any dynamic array resizing. Since we
|
||||
// insert the right elements on the right side in reverse order, we need to
|
||||
// reverse them back to the original order at the end.
|
||||
|
||||
|
||||
let count = self.count
|
||||
|
||||
|
||||
// Inside of the `initializer` closure, we set what the actual mid-point is.
|
||||
// We will use this to partition the single array into two.
|
||||
var midPoint: Int = 0
|
||||
|
||||
|
||||
let elements = try [Element](
|
||||
unsafeUninitializedCapacity: count,
|
||||
initializingWith: { buffer, initializedCount in
|
||||
var lhs = buffer.baseAddress!
|
||||
// swift-format-ignore: NeverForceUnwrap
|
||||
// Non-empty check above.
|
||||
let bufferStart = buffer.baseAddress!
|
||||
var lhs = bufferStart
|
||||
var rhs = lhs + buffer.count
|
||||
do {
|
||||
for element in self {
|
||||
@@ -315,26 +357,28 @@ extension Collection {
|
||||
lhs += 1
|
||||
}
|
||||
}
|
||||
|
||||
precondition(lhs == rhs, """
|
||||
|
||||
precondition(
|
||||
lhs == rhs,
|
||||
"""
|
||||
Collection's `count` differed from the number of elements iterated.
|
||||
"""
|
||||
)
|
||||
|
||||
let rhsIndex = rhs - buffer.baseAddress!
|
||||
|
||||
let rhsIndex = rhs - bufferStart
|
||||
buffer[rhsIndex...].reverse()
|
||||
initializedCount = buffer.count
|
||||
|
||||
|
||||
midPoint = rhsIndex
|
||||
} catch {
|
||||
let lhsCount = lhs - buffer.baseAddress!
|
||||
let rhsCount = (buffer.baseAddress! + buffer.count) - rhs
|
||||
buffer.baseAddress!.deinitialize(count: lhsCount)
|
||||
let lhsCount = lhs - bufferStart
|
||||
let rhsCount = (bufferStart + buffer.count) - rhs
|
||||
bufferStart.deinitialize(count: lhsCount)
|
||||
rhs.deinitialize(count: rhsCount)
|
||||
throw error
|
||||
}
|
||||
})
|
||||
|
||||
|
||||
let lhs = elements[..<midPoint]
|
||||
let rhs = elements[midPoint...]
|
||||
return (
|
||||
|
||||
@@ -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 sorted
|
||||
@@ -34,26 +33,27 @@ 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]
|
||||
// swift-format-ignore: NeverForceUnwrap
|
||||
// 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 +62,7 @@ extension MutableCollection
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if i == startIndex {
|
||||
self.reverse()
|
||||
return false
|
||||
@@ -80,17 +80,17 @@ public struct PermutationsSequence<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 `PermutationsSequence` for all permutations of `base` of
|
||||
/// size `k`.
|
||||
///
|
||||
@@ -102,13 +102,13 @@ public struct PermutationsSequence<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 `PermutationsSequence` for all combinations of `base` of
|
||||
/// sizes within a given range.
|
||||
///
|
||||
@@ -118,17 +118,18 @@ public struct PermutationsSequence<Base: Collection> {
|
||||
/// iterate over all permutations of the same size as the base collection.
|
||||
@inlinable
|
||||
internal init<R: RangeExpression>(
|
||||
_ base: Base, kRange: R?
|
||||
_ base: Base,
|
||||
kRange: R?
|
||||
) where R.Bound == Int {
|
||||
self.base = base
|
||||
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 {
|
||||
@@ -143,26 +144,26 @@ extension PermutationsSequence: 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)
|
||||
|
||||
/// Whether or not iteration is finished (`kRange` is empty).
|
||||
@inlinable
|
||||
internal var isFinished: Bool {
|
||||
return kRange.isEmpty
|
||||
kRange.isEmpty
|
||||
}
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var indexes: [Base.Index]
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(_ permutations: PermutationsSequence) {
|
||||
self.base = permutations.base
|
||||
@@ -170,7 +171,7 @@ extension PermutationsSequence: 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.
|
||||
///
|
||||
@@ -186,44 +187,49 @@ extension PermutationsSequence: 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 }) {
|
||||
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 }) {
|
||||
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 {
|
||||
@@ -231,7 +237,7 @@ extension PermutationsSequence: Sequence {
|
||||
}
|
||||
return []
|
||||
}
|
||||
|
||||
|
||||
let permutesFullCollection = (countToChoose == baseCount)
|
||||
if permutesFullCollection {
|
||||
// If we're permuting the full collection, each iteration is just a
|
||||
@@ -256,7 +262,7 @@ extension PermutationsSequence: Sequence {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(self)
|
||||
@@ -264,7 +270,7 @@ extension PermutationsSequence: Sequence {
|
||||
}
|
||||
|
||||
extension PermutationsSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// permutations(ofCount:)
|
||||
@@ -323,6 +329,8 @@ extension Collection {
|
||||
/// clamped to the number of elements in this collection. Passing a range
|
||||
/// covering sizes greater than the number of elements in this collection
|
||||
/// results in an empty sequence.
|
||||
/// - Returns: A sequence of the permutations of this collection's elements,
|
||||
/// for all sizes in `kRange`, from smallest to largest.
|
||||
///
|
||||
/// - Complexity: O(1) for random-access base collections. O(*n*) where *n*
|
||||
/// is the number of elements in the base collection, since
|
||||
@@ -333,7 +341,7 @@ extension Collection {
|
||||
) -> PermutationsSequence<Self> where R.Bound == Int {
|
||||
PermutationsSequence(self, kRange: kRange)
|
||||
}
|
||||
|
||||
|
||||
/// Returns a collection of the permutations of this collection of the
|
||||
/// specified length.
|
||||
///
|
||||
@@ -379,12 +387,15 @@ extension Collection {
|
||||
/// If `k` is `nil`, the resulting sequence represents permutations of this
|
||||
/// entire collection. If `k` is greater than the number of elements in
|
||||
/// this collection, the resulting sequence is empty.
|
||||
/// - Returns: A sequence of the permutations of this collection's elements.
|
||||
///
|
||||
/// - Complexity: O(1) for random-access base collections. O(*n*) where *n*
|
||||
/// is the number of elements in the base collection, since
|
||||
/// `PermutationsSequence` accesses the `count` of the base collection.
|
||||
@inlinable
|
||||
public func permutations(ofCount k: Int? = nil) -> PermutationsSequence<Self> {
|
||||
public func permutations(
|
||||
ofCount k: Int? = nil
|
||||
) -> PermutationsSequence<Self> {
|
||||
precondition(
|
||||
k ?? 0 >= 0,
|
||||
"Can't have permutations with a negative number of elements.")
|
||||
@@ -405,10 +416,10 @@ public struct UniquePermutationsSequence<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>
|
||||
}
|
||||
@@ -418,30 +429,31 @@ extension UniquePermutationsSequence where Base.Element: Hashable {
|
||||
internal static func _indexes(_ base: Base) -> [Base.Index] {
|
||||
let firstIndexesAndCountsByElement = Dictionary(
|
||||
base.indices.lazy.map { (base[$0], ($0, 1)) },
|
||||
uniquingKeysWith: { indexAndCount, _ in (indexAndCount.0, indexAndCount.1 + 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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -450,10 +462,10 @@ extension UniquePermutationsSequence: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var indexes: [Base.Index]
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var lengths: Range<Int>
|
||||
|
||||
@@ -461,19 +473,20 @@ extension UniquePermutationsSequence: Sequence {
|
||||
internal var initial = true
|
||||
|
||||
@inlinable
|
||||
internal init(_ elements: Base, indexes: [Base.Index], lengths: Range<Int>) {
|
||||
internal init(_ elements: Base, indexes: [Base.Index], lengths: Range<Int>)
|
||||
{
|
||||
self.base = elements
|
||||
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
|
||||
@@ -490,11 +503,11 @@ extension UniquePermutationsSequence: Sequence {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return indexes[..<lengths.lowerBound].map { base[$0] }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(base, indexes: indexes, lengths: kRange)
|
||||
@@ -502,7 +515,7 @@ extension UniquePermutationsSequence: Sequence {
|
||||
}
|
||||
|
||||
extension UniquePermutationsSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension Collection where Element: Hashable {
|
||||
/// Returns a sequence of the unique permutations of this sequence of the
|
||||
@@ -540,6 +553,8 @@ extension Collection where Element: Hashable {
|
||||
/// If `k` is `nil`, the resulting sequence represents permutations of this
|
||||
/// entire collection. If `k` is greater than the number of elements in
|
||||
/// this collection, the resulting sequence is empty.
|
||||
/// - Returns: A sequence of the unique permutations of this collection's
|
||||
/// elements.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the number of elements in this
|
||||
/// collection.
|
||||
@@ -547,11 +562,10 @@ extension Collection where Element: Hashable {
|
||||
public func uniquePermutations(ofCount k: Int? = nil)
|
||||
-> UniquePermutationsSequence<Self>
|
||||
{
|
||||
if let k = k {
|
||||
return UniquePermutationsSequence(self, k ..< (k + 1))
|
||||
} else {
|
||||
guard let k = k else {
|
||||
return UniquePermutationsSequence(self)
|
||||
}
|
||||
return UniquePermutationsSequence(self, k..<(k + 1))
|
||||
}
|
||||
|
||||
/// Returns a collection of the unique permutations of this sequence with
|
||||
@@ -580,6 +594,8 @@ extension Collection where Element: Hashable {
|
||||
/// clamped to the number of elements in this collection. Passing a range
|
||||
/// covering sizes greater than the number of elements in this collection
|
||||
/// results in an empty sequence.
|
||||
/// - Returns: A sequence of the unique permutations of this collection's
|
||||
/// elements, for all sizes in `kRange`, from smallest to largest.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the number of elements in this
|
||||
/// collection.
|
||||
|
||||
+140
-102
@@ -14,11 +14,11 @@ public struct Product2Sequence<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 Product2Sequence<Base1: Sequence, Base2: Collection> {
|
||||
|
||||
extension Product2Sequence: Sequence {
|
||||
public typealias Element = (Base1.Element, Base2.Element)
|
||||
|
||||
|
||||
/// The iterator for a `Product2Sequence` sequence.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
@@ -47,10 +47,12 @@ extension Product2Sequence: 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,27 +61,29 @@ extension Product2Sequence: 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() {
|
||||
// swift-format-ignore: NeverForceUnwrap
|
||||
// `element1` has a nil check above.
|
||||
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 }
|
||||
|
||||
i2 = base2.makeIterator()
|
||||
if let element2 = i2.next() {
|
||||
return (element1, element2)
|
||||
} else {
|
||||
guard let element1 else {
|
||||
return nil
|
||||
}
|
||||
|
||||
i2 = base2.makeIterator()
|
||||
guard let element2 = i2.next() else {
|
||||
return nil
|
||||
}
|
||||
return (element1, element2)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -96,43 +100,45 @@ extension Product2Sequence: 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.
|
||||
@@ -142,24 +148,24 @@ extension Product2Sequence: 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
|
||||
@@ -170,11 +176,11 @@ extension Product2Sequence: 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
|
||||
@@ -188,30 +194,30 @@ extension Product2Sequence: 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,
|
||||
@@ -232,51 +238,55 @@ extension Product2Sequence: 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
|
||||
_ 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) {
|
||||
|
||||
if let i2 =
|
||||
base2
|
||||
.index(i.i2, offsetBy: distance, limitedBy: base2.endIndex)
|
||||
{
|
||||
// `distance` does not overflow `base2[i.i2...]`.
|
||||
//
|
||||
// i.i2 i2
|
||||
// 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`.
|
||||
//
|
||||
@@ -286,12 +296,17 @@ extension Product2Sequence: 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)
|
||||
|
||||
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) {
|
||||
|
||||
if let i2 =
|
||||
base2
|
||||
.index(base2.startIndex, offsetBy: remaining, limitedBy: i.i2)
|
||||
{
|
||||
// `remaining` does not overflow `base2[..<i.i2]`.
|
||||
//
|
||||
// i.i2
|
||||
@@ -302,58 +317,66 @@ extension Product2Sequence: 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 }
|
||||
|
||||
|
||||
guard
|
||||
let i1 = base1.index(nextI1, offsetBy: base1Distance, limitedBy: limit.i1)
|
||||
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)
|
||||
return
|
||||
base2
|
||||
.index(base2.startIndex, offsetBy: base2Distance, limitedBy: base2Limit)
|
||||
.map { i2 in Index(i1: i1, i2: i2) }
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
_ 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`.
|
||||
//
|
||||
// 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) {
|
||||
|
||||
if let i2 =
|
||||
base2
|
||||
.index(i.i2, offsetBy: -distance, limitedBy: base2.startIndex)
|
||||
{
|
||||
// `distance` does not underflow `base2[..<i.i2]`.
|
||||
//
|
||||
// i2 i.i2
|
||||
// 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`.
|
||||
//
|
||||
@@ -363,12 +386,17 @@ extension Product2Sequence: 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)
|
||||
|
||||
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) {
|
||||
|
||||
if let i2 =
|
||||
base2
|
||||
.index(base2.endIndex, offsetBy: -remaining, limitedBy: i.i2)
|
||||
{
|
||||
// `remaining` does not underflow `base2[i.i2...]`.
|
||||
//
|
||||
// i2
|
||||
@@ -379,17 +407,17 @@ extension Product2Sequence: 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.
|
||||
@@ -402,46 +430,54 @@ extension Product2Sequence: 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
|
||||
} else {
|
||||
|
||||
guard
|
||||
let i1 = base1.index(
|
||||
previousI1,
|
||||
offsetBy: -(base1Distance - 1),
|
||||
limitedBy: limit.i1)
|
||||
else {
|
||||
return nil
|
||||
}
|
||||
let index = Index(i1: i1, i2: base2.startIndex)
|
||||
return index < limit ? nil : index
|
||||
}
|
||||
|
||||
guard let i1 = base1.index(previousI1, offsetBy: -base1Distance, limitedBy: limit.i1)
|
||||
else { return nil }
|
||||
|
||||
|
||||
guard
|
||||
let i1 =
|
||||
base1
|
||||
.index(previousI1, offsetBy: -base1Distance, limitedBy: limit.i1)
|
||||
else { return nil }
|
||||
|
||||
let base2Limit = limit.i1 == i1 ? limit.i2 : base2.startIndex
|
||||
return base2.index(base2.endIndex, offsetBy: -base2Distance, limitedBy: base2Limit)
|
||||
return
|
||||
base2
|
||||
.index(base2.endIndex, offsetBy: -base2Distance, limitedBy: base2Limit)
|
||||
.map { i2 in Index(i1: i1, i2: i2) }
|
||||
}
|
||||
}
|
||||
|
||||
extension Product2Sequence: 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")
|
||||
if i.i2 == base2.startIndex {
|
||||
return Index(
|
||||
i1: base1.index(before: i.i1),
|
||||
i2: base2.index(before: base2.endIndex))
|
||||
} else {
|
||||
precondition(
|
||||
i != startIndex,
|
||||
"Can't move before startIndex")
|
||||
guard i.i2 == base2.startIndex else {
|
||||
return Index(i1: i.i1, i2: base2.index(before: i.i2))
|
||||
}
|
||||
return Index(
|
||||
i1: base1.index(before: i.i1),
|
||||
i2: base2.index(before: base2.endIndex))
|
||||
}
|
||||
}
|
||||
|
||||
extension Product2Sequence: RandomAccessCollection
|
||||
where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
|
||||
where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
|
||||
|
||||
extension Product2Sequence.Index: Hashable
|
||||
where Base1.Index: Hashable, Base2.Index: Hashable {}
|
||||
where Base1.Index: Hashable, Base2.Index: Hashable {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// product(_:_:)
|
||||
@@ -454,7 +490,6 @@ extension Product2Sequence.Index: Hashable
|
||||
/// element of the tuple is from the first collection and the second element is
|
||||
/// from the second collection.
|
||||
///
|
||||
///
|
||||
/// let numbers = 1...3
|
||||
/// let colors = ["cerise", "puce", "heliotrope"]
|
||||
/// for (number, color) in product(numbers, colors) {
|
||||
@@ -478,11 +513,14 @@ extension Product2Sequence.Index: Hashable
|
||||
/// - Parameters:
|
||||
/// - s1: The first sequence to iterate over.
|
||||
/// - s2: The second sequence to iterate over.
|
||||
/// - Returns: A sequence of tuples, with every combination of the elements
|
||||
/// of `s1` and `s2`, in order.
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public func product<Base1: Sequence, Base2: Collection>(
|
||||
_ s1: Base1, _ s2: Base2
|
||||
_ s1: Base1,
|
||||
_ s2: Base2
|
||||
) -> Product2Sequence<Base1, Base2> {
|
||||
Product2Sequence(s1, s2)
|
||||
}
|
||||
@@ -10,13 +10,33 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// For log(_:) and root(_:_:)
|
||||
#if swift(>=5.11)
|
||||
#if ALGORITHMS_DARWIN_ONLY
|
||||
internal import Darwin
|
||||
|
||||
extension Double {
|
||||
@_transparent
|
||||
internal static func root(_ x: Double, _ n: Int) -> Double {
|
||||
guard x >= 0 || n % 2 != 0 else { return .nan }
|
||||
if n == 3 { return cbrt(x) }
|
||||
return Double(signOf: x, magnitudeOf: pow(x.magnitude, 1 / Double(n)))
|
||||
}
|
||||
|
||||
@_transparent
|
||||
internal static func log(_ x: Double) -> Double {
|
||||
Darwin.log(x)
|
||||
}
|
||||
|
||||
@_transparent
|
||||
internal static func log(onePlus x: Double) -> Double {
|
||||
Darwin.log1p(x)
|
||||
}
|
||||
}
|
||||
#elseif swift(>=5.11)
|
||||
internal import RealModule
|
||||
#elseif swift(>=5.10)
|
||||
import RealModule
|
||||
#else
|
||||
@_implementationOnly
|
||||
import RealModule
|
||||
@_implementationOnly import RealModule
|
||||
#endif
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
@@ -36,16 +56,17 @@ extension Collection {
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@inlinable
|
||||
public func randomStableSample<G: RandomNumberGenerator>(
|
||||
count k: Int, using rng: inout G
|
||||
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 {
|
||||
@@ -58,10 +79,10 @@ extension Collection {
|
||||
formIndex(after: &i)
|
||||
remainingCount -= 1
|
||||
}
|
||||
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
|
||||
/// Randomly selects the specified number of elements from this collection,
|
||||
/// maintaining their relative order.
|
||||
///
|
||||
@@ -90,14 +111,16 @@ extension Collection {
|
||||
|
||||
@usableFromInline
|
||||
internal func nextW<G: RandomNumberGenerator>(
|
||||
k: Int, using rng: inout G
|
||||
k: Int,
|
||||
using rng: inout G
|
||||
) -> Double {
|
||||
Double.root(.random(in: 0..<1, using: &rng), k)
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal func nextOffset<G: RandomNumberGenerator>(
|
||||
w: Double, using rng: inout G
|
||||
w: Double,
|
||||
using rng: inout G
|
||||
) -> Int {
|
||||
let offset = Double.log(.random(in: 0..<1, using: &rng)) / .log(onePlus: -w)
|
||||
return offset < Double(Int.max) ? Int(offset) : Int.max
|
||||
@@ -118,29 +141,30 @@ extension Collection {
|
||||
/// where *n* is the length of the collection.
|
||||
@inlinable
|
||||
public func randomSample<G: RandomNumberGenerator>(
|
||||
count k: Int, using rng: inout G
|
||||
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 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)
|
||||
@@ -148,12 +172,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
|
||||
@@ -187,14 +211,15 @@ extension Sequence {
|
||||
/// - Complexity: O(*n*), where *n* is the length of the sequence.
|
||||
@inlinable
|
||||
public func randomSample<G: RandomNumberGenerator>(
|
||||
count k: Int, using rng: inout G
|
||||
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() {
|
||||
@@ -204,26 +229,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() {
|
||||
while offset > 0, iterator.next() != nil {
|
||||
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
|
||||
|
||||
@@ -161,7 +161,7 @@ extension Sequence {
|
||||
_ transform: (inout Result, Element) throws -> Void
|
||||
) rethrows -> [Result] {
|
||||
|
||||
var output = [Result]()
|
||||
var output: [Result] = []
|
||||
output.reserveCapacity(underestimatedCount + 1)
|
||||
output.append(initial)
|
||||
|
||||
@@ -249,7 +249,7 @@ extension ExclusiveReductionsSequence: Collection where Base: Collection {
|
||||
case base(Base.Index, Result)
|
||||
case end
|
||||
}
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let representation: Representation
|
||||
|
||||
@@ -257,7 +257,7 @@ extension ExclusiveReductionsSequence: Collection where Base: Collection {
|
||||
internal init(_ representation: Representation) {
|
||||
self.representation = representation
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
switch (lhs.representation, rhs.representation) {
|
||||
@@ -269,7 +269,7 @@ extension ExclusiveReductionsSequence: Collection where Base: Collection {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
switch (lhs.representation, rhs.representation) {
|
||||
@@ -319,11 +319,11 @@ extension ExclusiveReductionsSequence: Collection where Base: Collection {
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
switch (start.representation, end.representation) {
|
||||
case let (.base(start, _), .base(end, _)):
|
||||
case (.base(let start, _), .base(let end, _)):
|
||||
return base.distance(from: start, to: end)
|
||||
case let (.base(index, _), .end):
|
||||
case (.base(let index, _), .end):
|
||||
return base.distance(from: index, to: base.endIndex) + 1
|
||||
case let (.end, .base(index, _)):
|
||||
case (.end, .base(let index, _)):
|
||||
return base.distance(from: base.endIndex, to: index) - 1
|
||||
case (.end, .end):
|
||||
return 0
|
||||
@@ -334,11 +334,10 @@ extension ExclusiveReductionsSequence: Collection where Base: Collection {
|
||||
extension ExclusiveReductionsSequence: LazySequenceProtocol {}
|
||||
|
||||
extension ExclusiveReductionsSequence: LazyCollectionProtocol
|
||||
where Base: Collection {}
|
||||
where Base: Collection {}
|
||||
|
||||
extension ExclusiveReductionsSequence.Index: Hashable
|
||||
where Base.Index: Hashable
|
||||
{
|
||||
where Base.Index: Hashable {
|
||||
@inlinable
|
||||
public func hash(into hasher: inout Hasher) {
|
||||
switch representation {
|
||||
@@ -483,7 +482,7 @@ extension InclusiveReductionsSequence: Collection where Base: Collection {
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal let base: Base.Index
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let result: Element?
|
||||
|
||||
@@ -497,7 +496,7 @@ extension InclusiveReductionsSequence: Collection where Base: Collection {
|
||||
public static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.base < rhs.base
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.base == rhs.base
|
||||
@@ -519,7 +518,7 @@ extension InclusiveReductionsSequence: Collection where Base: Collection {
|
||||
guard let result = index.result else {
|
||||
fatalError("Can't subscript using endIndex")
|
||||
}
|
||||
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
@@ -528,12 +527,13 @@ extension InclusiveReductionsSequence: Collection where Base: Collection {
|
||||
guard let result = index.result else {
|
||||
fatalError("Can't advance past endIndex")
|
||||
}
|
||||
|
||||
|
||||
let index = base.index(after: index.base)
|
||||
let nextResult = index == base.endIndex
|
||||
let nextResult =
|
||||
index == base.endIndex
|
||||
? nil
|
||||
: transform(result, base[index])
|
||||
|
||||
|
||||
return Index(base: index, result: nextResult)
|
||||
}
|
||||
|
||||
@@ -546,11 +546,10 @@ extension InclusiveReductionsSequence: Collection where Base: Collection {
|
||||
extension InclusiveReductionsSequence: LazySequenceProtocol {}
|
||||
|
||||
extension InclusiveReductionsSequence: LazyCollectionProtocol
|
||||
where Base: Collection {}
|
||||
where Base: Collection {}
|
||||
|
||||
extension InclusiveReductionsSequence.Index: Hashable
|
||||
where Base.Index: Hashable
|
||||
{
|
||||
where Base.Index: Hashable {
|
||||
@inlinable
|
||||
public func hash(into hasher: inout Hasher) {
|
||||
hasher.combine(base)
|
||||
|
||||
@@ -15,8 +15,10 @@
|
||||
|
||||
extension MutableCollection where Self: BidirectionalCollection {
|
||||
/// Reverses the elements of the collection, moving from each end until
|
||||
/// `limit` is reached from either direction. The returned indices are the
|
||||
/// start and end of the range of unreversed elements.
|
||||
/// `limit` is reached from either direction.
|
||||
///
|
||||
/// The returned indices are the start and end of the range of unreversed
|
||||
/// elements.
|
||||
///
|
||||
/// Input:
|
||||
/// [a b c d e f g h i j k l m n o p]
|
||||
@@ -28,11 +30,12 @@ extension MutableCollection where Self: BidirectionalCollection {
|
||||
/// lower upper
|
||||
///
|
||||
/// - Postcondition: For returned indices `(lower, upper)`:
|
||||
/// `lower == limit || upper == limit`
|
||||
/// `lower == limit || upper == limit`.
|
||||
@inlinable
|
||||
@discardableResult
|
||||
internal mutating func _reverse(
|
||||
subrange: Range<Index>, until limit: Index
|
||||
subrange: Range<Index>,
|
||||
until limit: Index
|
||||
) -> (Index, Index) {
|
||||
var lower = subrange.lowerBound
|
||||
var upper = subrange.upperBound
|
||||
@@ -43,7 +46,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
|
||||
@@ -75,8 +78,10 @@ extension MutableCollection where Self: BidirectionalCollection {
|
||||
|
||||
extension MutableCollection {
|
||||
/// Swaps the elements of the two given subranges, up to the upper bound of
|
||||
/// the smaller subrange. The returned indices are the ends of the two ranges
|
||||
/// that were actually swapped.
|
||||
/// the smaller subrange.
|
||||
///
|
||||
/// The returned indices are the ends of the two ranges that were actually
|
||||
/// swapped.
|
||||
///
|
||||
/// Input:
|
||||
/// [a b c d e f g h i j k l m n o p]
|
||||
@@ -96,19 +101,19 @@ extension MutableCollection {
|
||||
/// - p == lhs.upperBound || q == rhs.upperBound
|
||||
@inlinable
|
||||
internal mutating func _swapNonemptySubrangePrefixes(
|
||||
_ lhs: Range<Index>, _ rhs: Range<Index>
|
||||
_ lhs: Range<Index>,
|
||||
_ rhs: Range<Index>
|
||||
) -> (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 +144,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 (element j).
|
||||
@@ -154,7 +160,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).
|
||||
@@ -166,7 +172,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 is in s1.
|
||||
@@ -175,11 +181,11 @@ extension MutableCollection {
|
||||
// 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.
|
||||
//
|
||||
@@ -189,10 +195,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.
|
||||
///
|
||||
|
||||
@@ -86,7 +86,7 @@ extension SplitSequence: Sequence {
|
||||
self.omittingEmptySubsequences = omittingEmptySubsequences
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(
|
||||
@@ -101,25 +101,25 @@ extension SplitSequence: Sequence {
|
||||
extension SplitSequence.Iterator: IteratorProtocol {
|
||||
@inlinable
|
||||
public mutating func next() -> Element? {
|
||||
var currentElement = base.next()
|
||||
var nextElement = base.next()
|
||||
var subsequence: Element = []
|
||||
|
||||
// Add the next elements of the base sequence to this subsequence, until we
|
||||
// reach a separator, unless we've already split the maximum number of
|
||||
// times. In all cases, stop at the end of the base sequence.
|
||||
while currentElement != nil {
|
||||
if splitCount < maxSplits && isSeparator(currentElement!) {
|
||||
while let currentElement = nextElement {
|
||||
if splitCount < maxSplits && isSeparator(currentElement) {
|
||||
if omittingEmptySubsequences && subsequence.isEmpty {
|
||||
// Keep going if we don't want to return an empty subsequence.
|
||||
currentElement = base.next()
|
||||
nextElement = base.next()
|
||||
continue
|
||||
} else {
|
||||
splitCount += 1
|
||||
break
|
||||
}
|
||||
} else {
|
||||
subsequence.append(currentElement!)
|
||||
currentElement = base.next()
|
||||
subsequence.append(currentElement)
|
||||
nextElement = base.next()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -127,7 +127,7 @@ extension SplitSequence.Iterator: IteratorProtocol {
|
||||
// and we've either returned the maximum number of subsequences (one more
|
||||
// than the number of separators), or the only subsequence left to return is
|
||||
// empty and we're omitting those.
|
||||
if currentElement == nil
|
||||
if nextElement == nil
|
||||
&& (sequenceLength == splitCount + 1
|
||||
|| omittingEmptySubsequences && subsequence.isEmpty)
|
||||
{
|
||||
@@ -219,7 +219,7 @@ extension LazySequenceProtocol {
|
||||
/// satisfying the `isSeparator` predicate and for each element at the
|
||||
/// start or end of the sequence satisfying the `isSeparator`
|
||||
/// predicate. The default value is `true`.
|
||||
/// - whereSeparator: A closure that takes an element as an argument and
|
||||
/// - isSeparator: A closure that takes an element as an argument and
|
||||
/// returns a Boolean value indicating whether the sequence should be
|
||||
/// split at that element.
|
||||
/// - Returns: A lazy sequence of subsequences, split from this sequence's
|
||||
@@ -634,7 +634,7 @@ extension LazySequenceProtocol where Self: Collection, Elements: Collection {
|
||||
/// satisfying the `isSeparator` predicate and for each element at the
|
||||
/// start or end of the collection satisfying the `isSeparator`
|
||||
/// predicate. The default value is `true`.
|
||||
/// - whereSeparator: A closure that takes an element as an argument and
|
||||
/// - isSeparator: A closure that takes an element as an argument and
|
||||
/// returns a Boolean value indicating whether the collection should be
|
||||
/// split at that element.
|
||||
/// - Returns: A lazy collection of subsequences, split from this collection's
|
||||
@@ -659,8 +659,7 @@ extension LazySequenceProtocol where Self: Collection, Elements: Collection {
|
||||
}
|
||||
|
||||
extension LazySequenceProtocol
|
||||
where Self: Collection, Elements: Collection, Element: Equatable
|
||||
{
|
||||
where Self: Collection, Elements: Collection, Element: Equatable {
|
||||
/// Lazily returns the longest possible subsequences of the collection, in
|
||||
/// order, around elements equal to the given element.
|
||||
///
|
||||
|
||||
@@ -15,7 +15,7 @@
|
||||
|
||||
extension Sequence {
|
||||
/// Returns a sequence stepping through the elements every `step` starting at
|
||||
/// the first value. Any remainders of the stride will be trimmed.
|
||||
/// the first value.
|
||||
///
|
||||
/// (0...10).striding(by: 2) // == [0, 2, 4, 6, 8, 10]
|
||||
/// (0...10).striding(by: 3) // == [0, 3, 6, 9]
|
||||
@@ -24,8 +24,9 @@ extension Sequence {
|
||||
/// striding `step`.
|
||||
///
|
||||
/// - Parameter step: The amount to step with each iteration.
|
||||
/// - Returns: Returns a sequence for stepping through the elements by the
|
||||
/// specified amount.
|
||||
/// - Returns: A sequence for stepping through the elements by the specified
|
||||
/// amount. Any remaining elements after the last multiple of the stride
|
||||
/// are omitted.
|
||||
@inlinable
|
||||
public func striding(by step: Int) -> StridingSequence<Self> {
|
||||
StridingSequence(base: self, stride: step)
|
||||
@@ -34,18 +35,18 @@ extension Sequence {
|
||||
|
||||
extension Collection {
|
||||
/// Returns a sequence stepping through the elements every `step` starting at
|
||||
/// the first value. Any remainders of the stride will be trimmed.
|
||||
/// the first value.
|
||||
///
|
||||
/// (0...10).striding(by: 2) // == [0, 2, 4, 6, 8, 10]
|
||||
/// (0...10).striding(by: 3) // == [0, 3, 6, 9]
|
||||
///
|
||||
/// - Complexity: O(1). Access to successive values is O(1) if the collection
|
||||
/// conforms to `RandomAccessCollection`; otherwise, O(_k_), where _k_ is
|
||||
/// the striding `step`.
|
||||
/// - Complexity: O(1). Access to successive values is O(k) where _k_ is the
|
||||
/// striding `step`.
|
||||
///
|
||||
/// - Parameter step: The amount to step with each iteration.
|
||||
/// - Returns: Returns a collection for stepping through the elements by the
|
||||
/// specified amount.
|
||||
/// - Returns: A sequence for stepping through the elements by the specified
|
||||
/// amount. Any remaining elements after the last multiple of the stride
|
||||
/// are omitted.
|
||||
@inlinable
|
||||
public func striding(by step: Int) -> StridingCollection<Self> {
|
||||
StridingCollection(base: self, stride: step)
|
||||
@@ -56,10 +57,10 @@ extension Collection {
|
||||
public struct StridingSequence<Base: Sequence> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let stride: Int
|
||||
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, stride: Int) {
|
||||
precondition(stride > 0, "Stride must be greater than zero")
|
||||
@@ -80,19 +81,19 @@ extension StridingSequence: 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 {
|
||||
@@ -105,7 +106,7 @@ extension StridingSequence: Sequence {
|
||||
return iterator.next()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(iterator: base.makeIterator(), stride: stride)
|
||||
@@ -113,16 +114,16 @@ extension StridingSequence: Sequence {
|
||||
}
|
||||
|
||||
extension StridingSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
/// A wrapper that strides over a base collection.
|
||||
public struct StridingCollection<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")
|
||||
@@ -143,39 +144,39 @@ extension StridingCollection: 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 +185,12 @@ extension StridingCollection: 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,
|
||||
@@ -197,16 +198,17 @@ extension StridingCollection: Collection {
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
if limit < i {
|
||||
if let idx = base.index(
|
||||
i.base,
|
||||
offsetBy: n * stride,
|
||||
limitedBy: base.endIndex
|
||||
) {
|
||||
return Index(idx)
|
||||
} else {
|
||||
guard
|
||||
let idx = base.index(
|
||||
i.base,
|
||||
offsetBy: n * stride,
|
||||
limitedBy: base.endIndex
|
||||
)
|
||||
else {
|
||||
assert(distance(from: i, to: endIndex) == n, "Advancing past end index")
|
||||
return endIndex
|
||||
}
|
||||
return Index(idx)
|
||||
} else if let idx = base.index(
|
||||
i.base,
|
||||
offsetBy: n * stride,
|
||||
@@ -219,7 +221,7 @@ extension StridingCollection: Collection {
|
||||
: nil
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ i: Index,
|
||||
@@ -236,37 +238,41 @@ extension StridingCollection: Collection {
|
||||
distance = 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")
|
||||
precondition(distance >= 0 || i.base != base.startIndex, "Incrementing past start index")
|
||||
precondition(
|
||||
distance <= 0 || i.base != base.endIndex, "Advancing past end index")
|
||||
precondition(
|
||||
distance >= 0 || i.base != base.startIndex,
|
||||
"Incrementing past start index")
|
||||
let limit = distance > 0 ? endIndex : startIndex
|
||||
let idx = index(i, offsetBy: distance, limitedBy: limit)
|
||||
precondition(idx != nil, "The distance \(distance) is not valid for this collection")
|
||||
return idx!
|
||||
guard let idx = index(i, offsetBy: distance, limitedBy: limit) else {
|
||||
preconditionFailure(
|
||||
"The distance \(distance) is not valid for this collection")
|
||||
}
|
||||
return idx
|
||||
}
|
||||
}
|
||||
|
||||
extension StridingCollection: BidirectionalCollection
|
||||
where Base: RandomAccessCollection {
|
||||
|
||||
where Base: RandomAccessCollection {
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i.base != base.startIndex, "Incrementing past start index")
|
||||
@@ -275,9 +281,9 @@ extension StridingCollection: BidirectionalCollection
|
||||
}
|
||||
|
||||
extension StridingCollection: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension StridingCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension StridingCollection.Index: Hashable where Base.Index: Hashable {}
|
||||
@@ -14,13 +14,16 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension BidirectionalCollection {
|
||||
/// Returns a subsequence containing the elements from the end until
|
||||
/// `predicate` returns `false` and skipping the remaining elements.
|
||||
/// Returns a subsequence containing the suffix of this collection where
|
||||
/// all elements pass the given closure.
|
||||
///
|
||||
/// - Parameter predicate: A closure that takes an element of the sequence as
|
||||
/// its argument and returns `true` if the element should be included or
|
||||
/// `false` if it should be excluded. Once the predicate returns `false` it
|
||||
/// will not be called again.
|
||||
/// - Returns: A subsequence that is a suffix of the collection, where
|
||||
/// `predicate` returns `true` for all the elements of the returned
|
||||
/// subsequence.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@inlinable
|
||||
@@ -43,6 +46,8 @@ extension Collection {
|
||||
/// as its argument and returns `true` if the element is part of the prefix
|
||||
/// or `false` if it is not. Once the predicate returns `false` it will not
|
||||
/// be called again.
|
||||
/// - Returns: The index of the first element for which `predicate` does not
|
||||
/// succeed, or `endIndex` if all the collection's elements pass.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@inlinable
|
||||
@@ -69,6 +74,8 @@ extension BidirectionalCollection {
|
||||
/// as its argument and returns `true` if the element is part of the suffix
|
||||
/// or `false` if it is not. Once the predicate returns `false` it will not
|
||||
/// be called again.
|
||||
/// - Returns: The index of the last element for which `predicate` does not
|
||||
/// succeed, or `startIndex` if all the collection's elements pass.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@inlinable
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// trimmingPrefix(while:)
|
||||
@@ -14,19 +15,21 @@
|
||||
|
||||
extension Collection {
|
||||
/// Returns a `SubSequence` formed by discarding all elements at the start of
|
||||
/// the collection which satisfy the given predicate.
|
||||
/// the collection that satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trimmingPrefix(while:)` to get a substring without the
|
||||
/// white space at the beginning of the string:
|
||||
///
|
||||
/// let myString = " hello, world "
|
||||
/// print(myString.trimmingPrefix(while: \.isWhitespace)) // "hello, world "
|
||||
/// print(myString.trimmingPrefix(while: \.isWhitespace))
|
||||
/// // Prints "hello, world "
|
||||
///
|
||||
/// - Parameter predicate: A closure which determines if the element should be
|
||||
/// omitted from the resulting slice.
|
||||
/// - Parameter predicate: A closure that determines if the element should be
|
||||
/// omitted from the result.
|
||||
/// - Returns: A subsequence of this collection, starting at the first element
|
||||
/// for which `predicate` returns `false`.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
public func trimmingPrefix(
|
||||
while predicate: (Element) throws -> Bool
|
||||
@@ -41,7 +44,7 @@ extension Collection {
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Collection where Self: RangeReplaceableCollection {
|
||||
/// Mutates a `Collection` by discarding all elements at the start of it which
|
||||
/// Mutates the collection by discarding all elements at the start that
|
||||
/// satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trimPrefix(while:)` to remove the white space at the
|
||||
@@ -49,13 +52,13 @@ extension Collection where Self: RangeReplaceableCollection {
|
||||
///
|
||||
/// let myString = " hello, world "
|
||||
/// myString.trimPrefix(while: \.isWhitespace)
|
||||
/// print(myString) // "hello, world "
|
||||
/// print(myString)
|
||||
/// // Prints "hello, world "
|
||||
///
|
||||
/// - Parameter predicate: A closure which determines if the element should be
|
||||
/// removed from the string.
|
||||
/// - Parameter predicate: A closure that determines if the element should be
|
||||
/// removed from the result.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
@_disfavoredOverload
|
||||
public mutating func trimPrefix(
|
||||
@@ -67,7 +70,7 @@ extension Collection where Self: RangeReplaceableCollection {
|
||||
}
|
||||
|
||||
extension Collection where Self == Self.SubSequence {
|
||||
/// Mutates a `Collection` by discarding all elements at the start of it which
|
||||
/// Mutates the collection by discarding all elements at the start that
|
||||
/// satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trimPrefix(while:)` to remove the white space at the
|
||||
@@ -77,11 +80,10 @@ extension Collection where Self == Self.SubSequence {
|
||||
/// myString.trimPrefix(while: \.isWhitespace)
|
||||
/// print(myString) // "hello, world "
|
||||
///
|
||||
/// - Parameters predicate: A closure which determines if the element should
|
||||
/// - Parameters predicate: A closure that determines if the element should
|
||||
/// be removed from the string.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
public mutating func trimPrefix(
|
||||
while predicate: (Element) throws -> Bool
|
||||
@@ -96,28 +98,31 @@ extension Collection where Self == Self.SubSequence {
|
||||
|
||||
extension BidirectionalCollection {
|
||||
/// Returns a `SubSequence` formed by discarding all elements at the start and
|
||||
/// end of the collection which satisfy the given predicate.
|
||||
/// end of the collection that satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trimming(while:)` to get a substring without the white
|
||||
/// space at the beginning and end of the string:
|
||||
///
|
||||
/// let myString = " hello, world "
|
||||
/// print(myString.trimming(while: \.isWhitespace)) // "hello, world"
|
||||
/// print(myString.trimming(while: \.isWhitespace))
|
||||
/// // Prints "hello, world"
|
||||
///
|
||||
/// - Parameter predicate: A closure which determines if the element should be
|
||||
/// - Parameter predicate: A closure that determines if the element should be
|
||||
/// omitted from the resulting slice.
|
||||
/// - Returns: A subsequence of this collection, starting at the first element
|
||||
/// for which `predicate` returns `false` and ending at the last element for
|
||||
/// which `predicate` returns `true`.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
public func trimming(
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows -> SubSequence {
|
||||
try trimmingPrefix(while: predicate).trimmingSuffix(while: predicate)
|
||||
}
|
||||
|
||||
|
||||
/// Returns a `SubSequence` formed by discarding all elements at the end of
|
||||
/// the collection which satisfy the given predicate.
|
||||
/// the collection that satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trimmingSuffix(while:)` to get a substring without the
|
||||
/// white space at the end of the string:
|
||||
@@ -125,11 +130,12 @@ extension BidirectionalCollection {
|
||||
/// let myString = " hello, world "
|
||||
/// print(myString.trimmingSuffix(while: \.isWhitespace)) // " hello, world"
|
||||
///
|
||||
/// - Parameter predicate: A closure which determines if the element should be
|
||||
/// - Parameter predicate: A closure that determines if the element should be
|
||||
/// omitted from the resulting slice.
|
||||
/// - Returns: A subsequence of this collection, ending at the last element
|
||||
/// for which `predicate` returns `true`.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
public func trimmingSuffix(
|
||||
while predicate: (Element) throws -> Bool
|
||||
@@ -145,7 +151,7 @@ extension BidirectionalCollection {
|
||||
|
||||
extension BidirectionalCollection where Self: RangeReplaceableCollection {
|
||||
/// Mutates a `BidirectionalCollection` by discarding all elements at the
|
||||
/// start and at the end of it which satisfy the given predicate.
|
||||
/// start and at the end of it that satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trim(while:)` to remove the white space at the
|
||||
/// beginning of the string:
|
||||
@@ -154,11 +160,10 @@ extension BidirectionalCollection where Self: RangeReplaceableCollection {
|
||||
/// myString.trim(while: \.isWhitespace)
|
||||
/// print(myString) // "hello, world"
|
||||
///
|
||||
/// - Parameter predicate: A closure which determines if the element should be
|
||||
/// - Parameter predicate: A closure that determines if the element should be
|
||||
/// removed from the string.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
@_disfavoredOverload
|
||||
public mutating func trim(
|
||||
@@ -167,9 +172,9 @@ extension BidirectionalCollection where Self: RangeReplaceableCollection {
|
||||
try trimSuffix(while: predicate)
|
||||
try trimPrefix(while: predicate)
|
||||
}
|
||||
|
||||
|
||||
/// Mutates a `BidirectionalCollection` by discarding all elements at the end
|
||||
/// of it which satisfy the given predicate.
|
||||
/// of it that satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trimSuffix(while:)` to remove the white space at the
|
||||
/// beginning of the string:
|
||||
@@ -178,11 +183,10 @@ extension BidirectionalCollection where Self: RangeReplaceableCollection {
|
||||
/// myString.trimSuffix(while: \.isWhitespace)
|
||||
/// print(myString) // " hello, world"
|
||||
///
|
||||
/// - Parameter predicate: A closure which determines if the element should be
|
||||
/// - Parameter predicate: A closure that determines if the element should be
|
||||
/// removed from the string.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
@_disfavoredOverload
|
||||
public mutating func trimSuffix(
|
||||
@@ -195,7 +199,7 @@ extension BidirectionalCollection where Self: RangeReplaceableCollection {
|
||||
|
||||
extension BidirectionalCollection where Self == Self.SubSequence {
|
||||
/// Mutates a `BidirectionalCollection` by discarding all elements at the
|
||||
/// start and at the end of it which satisfy the given predicate.
|
||||
/// start and at the end of it that satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trim(while:)` to remove the white space at the
|
||||
/// beginning of the string:
|
||||
@@ -204,11 +208,10 @@ extension BidirectionalCollection where Self == Self.SubSequence {
|
||||
/// myString.trim(while: \.isWhitespace)
|
||||
/// print(myString) // "hello, world"
|
||||
///
|
||||
/// - Parameter predicate: A closure which determines if the element should be
|
||||
/// - Parameter predicate: A closure that determines if the element should be
|
||||
/// removed from the string.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
public mutating func trim(
|
||||
while predicate: (Element) throws -> Bool
|
||||
@@ -217,7 +220,7 @@ extension BidirectionalCollection where Self == Self.SubSequence {
|
||||
}
|
||||
|
||||
/// Mutates a `BidirectionalCollection` by discarding all elements at the end
|
||||
/// of it which satisfy the given predicate.
|
||||
/// of it that satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trimSuffix(while:)` to remove the white space at the
|
||||
/// beginning of the string:
|
||||
@@ -226,11 +229,10 @@ extension BidirectionalCollection where Self == Self.SubSequence {
|
||||
/// myString.trimSuffix(while: \.isWhitespace)
|
||||
/// print(myString) // " hello, world"
|
||||
///
|
||||
/// - Parameter predicate: A closure which determines if the element should be
|
||||
/// - Parameter predicate: A closure that determines if the element should be
|
||||
/// removed from the string.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
public mutating func trimSuffix(
|
||||
while predicate: (Element) throws -> Bool
|
||||
|
||||
@@ -14,11 +14,11 @@ public struct UniquedSequence<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 UniquedSequence: 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 UniquedSequence: Sequence {
|
||||
self.base = base
|
||||
self.projection = projection
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Base.Element? {
|
||||
while let element = base.next() {
|
||||
@@ -57,7 +57,7 @@ extension UniquedSequence: Sequence {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(base: base.makeIterator(), projection: projection)
|
||||
@@ -65,7 +65,7 @@ extension UniquedSequence: Sequence {
|
||||
}
|
||||
|
||||
extension UniquedSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// uniqued()
|
||||
|
||||
@@ -49,10 +49,10 @@ extension Collection {
|
||||
public struct WindowsOfCountCollection<Base: Collection> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal let windowSize: Int
|
||||
|
||||
|
||||
@usableFromInline
|
||||
internal var endOfFirstWindow: Base.Index?
|
||||
|
||||
@@ -62,7 +62,8 @@ public struct WindowsOfCountCollection<Base: Collection> {
|
||||
self.base = base
|
||||
self.windowSize = windowSize
|
||||
self.endOfFirstWindow =
|
||||
base.index(base.startIndex, offsetBy: windowSize, limitedBy: base.endIndex)
|
||||
base
|
||||
.index(base.startIndex, offsetBy: windowSize, limitedBy: base.endIndex)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -71,41 +72,40 @@ extension WindowsOfCountCollection: 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 = endOfFirstWindow {
|
||||
return Index(lowerBound: base.startIndex, upperBound: upperBound)
|
||||
} else {
|
||||
guard let upperBound = endOfFirstWindow else {
|
||||
return endIndex
|
||||
}
|
||||
return Index(lowerBound: base.startIndex, upperBound: upperBound)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(lowerBound: base.endIndex, upperBound: base.endIndex)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public subscript(index: Index) -> Base.SubSequence {
|
||||
precondition(
|
||||
@@ -113,28 +113,29 @@ extension WindowsOfCountCollection: 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")
|
||||
guard index.upperBound < base.endIndex else { return endIndex }
|
||||
|
||||
let lowerBound = windowSize == 1
|
||||
|
||||
let lowerBound =
|
||||
windowSize == 1
|
||||
? index.upperBound
|
||||
: base.index(after: index.lowerBound)
|
||||
let upperBound = base.index(after: index.upperBound)
|
||||
return Index(lowerBound: lowerBound, upperBound: 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,
|
||||
@@ -143,7 +144,7 @@ extension WindowsOfCountCollection: 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)
|
||||
@@ -154,28 +155,30 @@ extension WindowsOfCountCollection: 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
|
||||
_ 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`
|
||||
@@ -186,31 +189,31 @@ extension WindowsOfCountCollection: 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 >= windowSize {
|
||||
// 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 - windowSize,
|
||||
limitedBy: limit.lowerBound),
|
||||
let indexBeforeUpperBound = base.index(
|
||||
lowerBound,
|
||||
offsetBy: windowSize - 1,
|
||||
limitedBy: limit.upperBound)
|
||||
let lowerBound = base.index(
|
||||
i.upperBound,
|
||||
offsetBy: distance - windowSize,
|
||||
limitedBy: limit.lowerBound),
|
||||
let indexBeforeUpperBound = base.index(
|
||||
lowerBound,
|
||||
offsetBy: windowSize - 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))
|
||||
@@ -218,35 +221,38 @@ extension WindowsOfCountCollection: 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.
|
||||
@@ -256,13 +262,14 @@ extension WindowsOfCountCollection: 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: -windowSize),
|
||||
upperBound: upperBound)
|
||||
@@ -274,14 +281,14 @@ extension WindowsOfCountCollection: 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 - windowSize),
|
||||
limitedBy: limit.upperBound)
|
||||
let upperBound = base.index(
|
||||
i.lowerBound,
|
||||
offsetBy: -(distance - windowSize),
|
||||
limitedBy: limit.upperBound)
|
||||
else { return nil }
|
||||
|
||||
|
||||
return Index(
|
||||
lowerBound: base.index(upperBound, offsetBy: -windowSize),
|
||||
upperBound: upperBound)
|
||||
@@ -289,19 +296,20 @@ extension WindowsOfCountCollection: 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) }
|
||||
@@ -319,42 +327,39 @@ extension WindowsOfCountCollection: 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 windowSize + 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
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension WindowsOfCountCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
where Base: BidirectionalCollection {
|
||||
@inlinable
|
||||
public func index(before index: Index) -> Index {
|
||||
precondition(index != startIndex, "Incrementing past start index")
|
||||
precondition(index != startIndex, "Decrementing past start index")
|
||||
if index == endIndex {
|
||||
return Index(
|
||||
lowerBound: base.index(index.lowerBound, offsetBy: -windowSize),
|
||||
upperBound: index.upperBound
|
||||
)
|
||||
upperBound: index.upperBound)
|
||||
} else {
|
||||
return Index(
|
||||
lowerBound: base.index(before: index.lowerBound),
|
||||
upperBound: base.index(before: index.upperBound)
|
||||
)
|
||||
upperBound: base.index(before: index.upperBound))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension WindowsOfCountCollection: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension WindowsOfCountCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension WindowsOfCountCollection.Index: Hashable where Base.Index: Hashable {}
|
||||
@@ -9,63 +9,63 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class AdjacentPairsTests: XCTestCase {
|
||||
func testEmptySequence() {
|
||||
let pairs = (0...).prefix(0).adjacentPairs()
|
||||
XCTAssertEqualSequences(pairs, [], by: ==)
|
||||
expectEqualSequences(pairs, [], by: ==)
|
||||
}
|
||||
|
||||
|
||||
func testOneElementSequence() {
|
||||
let pairs = (0...).prefix(1).adjacentPairs()
|
||||
XCTAssertEqualSequences(pairs, [], by: ==)
|
||||
expectEqualSequences(pairs, [], by: ==)
|
||||
}
|
||||
|
||||
|
||||
func testTwoElementSequence() {
|
||||
let pairs = (0...).prefix(2).adjacentPairs()
|
||||
XCTAssertEqualSequences(pairs, [(0, 1)], by: ==)
|
||||
expectEqualSequences(pairs, [(0, 1)], by: ==)
|
||||
}
|
||||
|
||||
|
||||
func testThreeElementSequence() {
|
||||
let pairs = (0...).prefix(3).adjacentPairs()
|
||||
XCTAssertEqualSequences(pairs, [(0, 1), (1, 2)], by: ==)
|
||||
expectEqualSequences(pairs, [(0, 1), (1, 2)], by: ==)
|
||||
}
|
||||
|
||||
|
||||
func testManySequences() {
|
||||
for n in 4...100 {
|
||||
let pairs = (0...).prefix(n).adjacentPairs()
|
||||
XCTAssertEqualSequences(pairs, zip(0..., 1...).prefix(n - 1), by: ==)
|
||||
expectEqualSequences(pairs, zip(0..., 1...).prefix(n - 1), by: ==)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testZeroElements() {
|
||||
let pairs = (0..<0).adjacentPairs()
|
||||
XCTAssertEqual(pairs.startIndex, pairs.endIndex)
|
||||
XCTAssertEqualSequences(pairs, [], by: ==)
|
||||
expectEqualSequences(pairs, [], by: ==)
|
||||
}
|
||||
|
||||
func testOneElement() {
|
||||
let pairs = (0..<1).adjacentPairs()
|
||||
XCTAssertEqual(pairs.startIndex, pairs.endIndex)
|
||||
XCTAssertEqualSequences(pairs, [], by: ==)
|
||||
expectEqualSequences(pairs, [], by: ==)
|
||||
}
|
||||
|
||||
func testTwoElements() {
|
||||
let pairs = (0..<2).adjacentPairs()
|
||||
XCTAssertEqualSequences(pairs, [(0, 1)], by: ==)
|
||||
expectEqualSequences(pairs, [(0, 1)], by: ==)
|
||||
}
|
||||
|
||||
func testThreeElements() {
|
||||
let pairs = (0..<3).adjacentPairs()
|
||||
XCTAssertEqualSequences(pairs, [(0, 1), (1, 2)], by: ==)
|
||||
expectEqualSequences(pairs, [(0, 1), (1, 2)], by: ==)
|
||||
}
|
||||
|
||||
func testManyElements() {
|
||||
for n in 4...100 {
|
||||
let pairs = (0..<n).adjacentPairs()
|
||||
XCTAssertEqualSequences(pairs, zip(0..., 1...).prefix(n - 1), by: ==)
|
||||
expectEqualSequences(pairs, zip(0..., 1...).prefix(n - 1), by: ==)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -76,9 +76,9 @@ final class AdjacentPairsTests: XCTestCase {
|
||||
validator.validate((0..<2).adjacentPairs(), expectedCount: 1)
|
||||
validator.validate((0..<5).adjacentPairs(), expectedCount: 4)
|
||||
}
|
||||
|
||||
|
||||
func testLaziness() {
|
||||
XCTAssertLazySequence((0...).lazy.adjacentPairs())
|
||||
XCTAssertLazyCollection((0..<100).lazy.adjacentPairs())
|
||||
requireLazySequence((0...).lazy.adjacentPairs())
|
||||
requireLazyCollection((0..<100).lazy.adjacentPairs())
|
||||
}
|
||||
}
|
||||
@@ -10,31 +10,32 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
|
||||
@testable import Algorithms
|
||||
|
||||
final class ChainTests: XCTestCase {
|
||||
func testChainSequences() {
|
||||
let run = chain((1...).prefix(10), 20...)
|
||||
XCTAssertEqualSequences(run.prefix(20), Array(1...10) + (20..<30))
|
||||
expectEqualSequences(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))
|
||||
expectEqualSequences(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")
|
||||
|
||||
expectEqualSequences(c, "ABCDEFGHIJklmnopqrstuv")
|
||||
expectEqualSequences(c.reversed(), "ABCDEFGHIJklmnopqrstuv".reversed())
|
||||
expectEqualSequences(chain(s1.reversed(), s2), "JIHGFEDCBAklmnopqrstuv")
|
||||
}
|
||||
|
||||
|
||||
func testChainIndexTraversals() {
|
||||
let validator = IndexValidator<Chain2Sequence<String, String>>(
|
||||
indicesIncludingEnd: { chain in
|
||||
@@ -42,27 +43,27 @@ final class ChainTests: XCTestCase {
|
||||
+ chain.base2.indices.map { .init(second: $0) }
|
||||
+ [.init(second: chain.base2.endIndex)]
|
||||
})
|
||||
|
||||
|
||||
validator.validate(chain("abcd", "XYZ"), expectedCount: 4 + 3)
|
||||
validator.validate(chain("abcd", ""), expectedCount: 4 + 0)
|
||||
validator.validate(chain("", "XYZ"), expectedCount: 0 + 3)
|
||||
validator.validate(chain("", ""), expectedCount: 0 + 0)
|
||||
}
|
||||
|
||||
|
||||
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],
|
||||
@@ -34,16 +33,17 @@ final class ChunkedTests: XCTestCase {
|
||||
fruits[18..<19],
|
||||
fruits[19..<22],
|
||||
]
|
||||
XCTAssertEqualSequences(expectedChunks, fruitChunks, by: ==)
|
||||
|
||||
expectEqualSequences(expectedChunks, fruitChunks, by: ==)
|
||||
|
||||
XCTAssertEqual(fruits[19..<22], fruitChunks.last)
|
||||
|
||||
XCTAssertEqual("Currant", fruitChunks.first(where: { $0.count == 4 })?.first)
|
||||
|
||||
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"]
|
||||
@@ -51,9 +51,10 @@ final class ChunkedTests: XCTestCase {
|
||||
let expected: [(Character, ArraySlice<String>)] = [
|
||||
("D", ["David"]),
|
||||
("K", ["Kyle", "Karoy"]),
|
||||
("N", ["Nate"])]
|
||||
XCTAssertEqualSequences(expected, chunks, by: ==)
|
||||
|
||||
("N", ["Nate"]),
|
||||
]
|
||||
expectEqualSequences(expected, chunks, by: ==)
|
||||
|
||||
// Empty sequence
|
||||
XCTAssertEqual(0, names.prefix(0).chunked(on: { $0.first }).count)
|
||||
|
||||
@@ -61,10 +62,10 @@ 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 }).map { $1 })
|
||||
|
||||
|
||||
let lazyChunks = fruits.lazy.chunked(on: { $0.first })
|
||||
validateFruitChunks(lazyChunks.map { $1 })
|
||||
IndexValidator().validate(lazyChunks)
|
||||
@@ -72,73 +73,83 @@ final class ChunkedTests: XCTestCase {
|
||||
|
||||
func testChunkedBy() {
|
||||
validateFruitChunks(fruits.chunked(by: { $0.first == $1.first }))
|
||||
|
||||
|
||||
let lazyChunks = fruits.lazy.chunked(by: { $0.first == $1.first })
|
||||
validateFruitChunks(lazyChunks)
|
||||
IndexValidator().validate(lazyChunks)
|
||||
}
|
||||
|
||||
|
||||
func testChunkedByComparesConsecutiveElements() {
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
[1, 2, 3, 4, 6, 7, 8, 9].chunked(by: { $1 - $0 == 1 }),
|
||||
[[1, 2, 3, 4], [6, 7, 8, 9]])
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
|
||||
expectEqualSequences(
|
||||
[1, 2, 3, 4, 6, 7, 8, 9].lazy.chunked(by: { $1 - $0 == 1 }),
|
||||
[[1, 2, 3, 4], [6, 7, 8, 9]])
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
|
||||
expectEqualSequences(
|
||||
[1, 2, 3, 4, 6, 7, 8, 9].lazy.chunked(by: { $1 - $0 == 1 }).reversed(),
|
||||
[[6, 7, 8, 9], [1, 2, 3, 4]])
|
||||
|
||||
|
||||
IndexValidator().validate([1, 2, 3].lazy.chunked(by: { $1 - $0 == 1 }))
|
||||
}
|
||||
|
||||
|
||||
func testChunkedLazy() {
|
||||
XCTAssertLazySequence(fruits.lazy.chunked(by: { $0.first == $1.first }))
|
||||
XCTAssertLazySequence(fruits.lazy.chunked(on: { $0.first }))
|
||||
requireLazySequence(fruits.lazy.chunked(by: { $0.first == $1.first }))
|
||||
requireLazySequence(fruits.lazy.chunked(on: { $0.first }))
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Tests for `chunks(ofCount:)`
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
|
||||
func testChunksOfCount() {
|
||||
XCTAssertEqualSequences([Int]().chunks(ofCount: 1), [])
|
||||
XCTAssertEqualSequences([Int]().chunks(ofCount: 5), [])
|
||||
expectEqualSequences([Int]().chunks(ofCount: 1), [])
|
||||
expectEqualSequences([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]])
|
||||
|
||||
expectEqualSequences(
|
||||
collection1.chunks(ofCount: 1),
|
||||
[[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])
|
||||
expectEqualSequences(
|
||||
collection1.chunks(ofCount: 3),
|
||||
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]])
|
||||
expectEqualSequences(
|
||||
collection1.chunks(ofCount: 5),
|
||||
[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
|
||||
expectEqualSequences(
|
||||
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]])
|
||||
expectEqualSequences(
|
||||
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]])
|
||||
|
||||
expectEqualSequences(
|
||||
collection1.chunks(ofCount: 1).reversed(),
|
||||
[[10], [9], [8], [7], [6], [5], [4], [3], [2], [1]])
|
||||
expectEqualSequences(
|
||||
collection1.chunks(ofCount: 3).reversed(),
|
||||
[[10], [7, 8, 9], [4, 5, 6], [1, 2, 3]])
|
||||
expectEqualSequences(
|
||||
collection1.chunks(ofCount: 5).reversed(),
|
||||
[[6, 7, 8, 9, 10], [1, 2, 3, 4, 5]])
|
||||
expectEqualSequences(
|
||||
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]])
|
||||
expectEqualSequences(
|
||||
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)
|
||||
@@ -148,20 +159,20 @@ 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)
|
||||
|
||||
|
||||
IndexValidator().validate(emptyChunks, expectedCount: 0)
|
||||
}
|
||||
|
||||
|
||||
func testChunksOfCountTraversal() {
|
||||
let validator = IndexValidator<ChunksOfCountCollection<ClosedRange<Int>>>()
|
||||
|
||||
|
||||
for i in 1...10 {
|
||||
let range = 1...50
|
||||
let chunks = range.chunks(ofCount: i)
|
||||
@@ -170,29 +181,29 @@ final class ChunkedTests: XCTestCase {
|
||||
expectedCount: range.count / i + (range.count % i).signum())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testEvenChunks() {
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
(0..<10).evenlyChunked(in: 4),
|
||||
[0..<3, 3..<6, 6..<8, 8..<10])
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
|
||||
expectEqualSequences(
|
||||
(0..<3).evenlyChunked(in: 5),
|
||||
[0..<1, 1..<2, 2..<3, 3..<3, 3..<3])
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
|
||||
expectEqualSequences(
|
||||
"".evenlyChunked(in: 0),
|
||||
[])
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
|
||||
expectEqualSequences(
|
||||
"".evenlyChunked(in: 1),
|
||||
[""])
|
||||
}
|
||||
|
||||
|
||||
func testEvenChunksIndexTraversals() {
|
||||
let validator = IndexValidator<EvenlyChunkedCollection<Range<Int>>>()
|
||||
|
||||
[
|
||||
for chunks in [
|
||||
(0..<10).evenlyChunked(in: 1),
|
||||
(0..<10).evenlyChunked(in: 2),
|
||||
(0..<10).evenlyChunked(in: 3),
|
||||
@@ -201,6 +212,8 @@ final class ChunkedTests: XCTestCase {
|
||||
(0..<0).evenlyChunked(in: 0),
|
||||
(0..<0).evenlyChunked(in: 1),
|
||||
(0..<0).evenlyChunked(in: 10),
|
||||
].forEach { validator.validate($0) }
|
||||
] {
|
||||
validator.validate(chunks)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -9,8 +9,8 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class CombinationsTests: XCTestCase {
|
||||
func testCount() {
|
||||
@@ -20,8 +20,8 @@ final class CombinationsTests: XCTestCase {
|
||||
/// the given `file` and `line`.
|
||||
func check(
|
||||
_ x: CombinationsSequence<String>, countsAre l: Int,
|
||||
file: StaticString, line: UInt)
|
||||
{
|
||||
file: StaticString, line: UInt
|
||||
) {
|
||||
XCTAssertEqual(x.count, l, "unexpected count", file: file, line: line)
|
||||
XCTAssertEqual(
|
||||
x.underestimatedCount, l, "unexpected underestimatedCount",
|
||||
@@ -34,8 +34,8 @@ final class CombinationsTests: XCTestCase {
|
||||
func check(
|
||||
cHas n: Int,
|
||||
combinationsOfLength l: Int,
|
||||
file: StaticString = #filePath, line: UInt = #line)
|
||||
{
|
||||
file: StaticString = #filePath, line: UInt = #line
|
||||
) {
|
||||
check(c.combinations(ofCount: l), countsAre: n, file: file, line: line)
|
||||
}
|
||||
|
||||
@@ -45,8 +45,8 @@ final class CombinationsTests: XCTestCase {
|
||||
func check<R: RangeExpression>(
|
||||
cHas n: Int,
|
||||
combinationsOfLengths l: R,
|
||||
file: StaticString = #filePath, line: UInt = #line) where R.Bound == Int
|
||||
{
|
||||
file: StaticString = #filePath, line: UInt = #line
|
||||
) where R.Bound == Int {
|
||||
check(c.combinations(ofCount: l), countsAre: n, file: file, line: line)
|
||||
}
|
||||
|
||||
@@ -63,70 +63,92 @@ final class CombinationsTests: XCTestCase {
|
||||
|
||||
// `k` greater than element count results in same number of combinations
|
||||
check(cHas: 5, combinationsOfLengths: 3...10)
|
||||
|
||||
|
||||
// `k` greater than element count results in same number of combinations
|
||||
check(cHas: 1, combinationsOfLengths: 4...10)
|
||||
|
||||
|
||||
// `k` entirely greater than element count results in no combinations
|
||||
check(cHas: 0, combinationsOfLengths: 5...10)
|
||||
|
||||
|
||||
check(cHas: 16, combinationsOfLengths: 0...)
|
||||
check(cHas: 15, combinationsOfLengths: ...3)
|
||||
}
|
||||
|
||||
|
||||
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))
|
||||
|
||||
expectEqualSequences([[]], "".combinations(ofCount: 0))
|
||||
expectEqualSequences([[]], "".combinations(ofCount: 0...0))
|
||||
expectEqualSequences([[]], "ABCD".combinations(ofCount: 0))
|
||||
expectEqualSequences([[]], "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))
|
||||
expectEqualSequences([], "".combinations(ofCount: 5))
|
||||
expectEqualSequences([], "".combinations(ofCount: 5...10))
|
||||
expectEqualSequences([], "ABCD".combinations(ofCount: 5))
|
||||
expectEqualSequences([], "ABCD".combinations(ofCount: 5...10))
|
||||
}
|
||||
|
||||
|
||||
func testCombinationsLazy() {
|
||||
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1))
|
||||
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1...3))
|
||||
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1...))
|
||||
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: ...3))
|
||||
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 0...))
|
||||
requireLazySequence("ABC".lazy.combinations(ofCount: 1))
|
||||
requireLazySequence("ABC".lazy.combinations(ofCount: 1...3))
|
||||
requireLazySequence("ABC".lazy.combinations(ofCount: 1...))
|
||||
requireLazySequence("ABC".lazy.combinations(ofCount: ...3))
|
||||
requireLazySequence("ABC".lazy.combinations(ofCount: 0...))
|
||||
}
|
||||
}
|
||||
@@ -9,33 +9,34 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
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)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
seq.compactMap({ $0 }), seq.compacted())
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
collection.compactMap({ $0 }), collection.compacted())
|
||||
}
|
||||
}
|
||||
|
||||
func testCompactedBidirectionalCollection() {
|
||||
for array in self.tests {
|
||||
XCTAssertEqualSequences(array.compactMap({ $0 }).reversed(),
|
||||
array.compacted().reversed())
|
||||
expectEqualSequences(
|
||||
array.compactMap({ $0 }).reversed(),
|
||||
array.compacted().reversed())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testCollectionTraversals() {
|
||||
let validator = IndexValidator<CompactedCollection<[Int?], Int>>()
|
||||
for array in self.tests {
|
||||
|
||||
@@ -9,13 +9,13 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class CycleTests: XCTestCase {
|
||||
func testCycle() {
|
||||
let cycle = (1...4).cycled()
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4],
|
||||
cycle.prefix(20)
|
||||
)
|
||||
@@ -32,12 +32,12 @@ final class CycleTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testCycleLazy() {
|
||||
XCTAssertLazySequence((1...4).lazy.cycled())
|
||||
requireLazySequence((1...4).lazy.cycled())
|
||||
}
|
||||
|
||||
func testRepeated() {
|
||||
let repeats = (1...4).cycled(times: 3)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4],
|
||||
repeats)
|
||||
}
|
||||
@@ -58,7 +58,7 @@ final class CycleTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testRepeatedLazy() {
|
||||
XCTAssertLazySequence((1...4).lazy.cycled(times: 3))
|
||||
requireLazySequence((1...4).lazy.cycled(times: 3))
|
||||
}
|
||||
|
||||
func testRepeatedIndexMethods() {
|
||||
@@ -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)
|
||||
|
||||
@@ -0,0 +1,97 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2021 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class EndsWithTests: XCTestCase {
|
||||
func testEndsWithCorrectSuffix() {
|
||||
let a = 8...10
|
||||
let b = 1...10
|
||||
|
||||
XCTAssertTrue(b.ends(with: a))
|
||||
}
|
||||
|
||||
func testDoesntEndWithWrongSuffix() {
|
||||
let a = 8...9
|
||||
let b = 1...10
|
||||
|
||||
XCTAssertFalse(b.ends(with: a))
|
||||
}
|
||||
|
||||
func testDoesntEndWithTooLongSuffix() {
|
||||
XCTAssertFalse((2...5).ends(with: (1...10)))
|
||||
}
|
||||
|
||||
func testEndsWithEmpty() {
|
||||
let a = 8...10
|
||||
let empty: [Int] = []
|
||||
XCTAssertTrue(a.ends(with: empty))
|
||||
}
|
||||
|
||||
func testEmptyEndsWithEmpty() {
|
||||
let empty: [Int] = []
|
||||
XCTAssertTrue(empty.ends(with: empty))
|
||||
}
|
||||
|
||||
func testEmptyDoesNotEndWithNonempty() {
|
||||
XCTAssertFalse([].ends(with: 1...10))
|
||||
}
|
||||
}
|
||||
|
||||
final class EndsWithNonEquatableTests: XCTestCase {
|
||||
func testEndsWithCorrectSuffix() {
|
||||
let a = nonEq(8...10)
|
||||
let b = nonEq(1...10)
|
||||
|
||||
XCTAssertTrue(b.ends(with: a, by: areEquivalent))
|
||||
}
|
||||
|
||||
func testDoesntEndWithWrongSuffix() {
|
||||
let a = nonEq(8...9)
|
||||
let b = nonEq(1...10)
|
||||
|
||||
XCTAssertFalse(b.ends(with: a, by: areEquivalent))
|
||||
}
|
||||
|
||||
func testDoesntEndWithTooLongSuffix() {
|
||||
XCTAssertFalse(nonEq(2...5).ends(with: nonEq(1...10), by: areEquivalent))
|
||||
}
|
||||
|
||||
func testEndsWithEmpty() {
|
||||
let a = nonEq(8...10)
|
||||
let empty: [NotEquatable<Int>] = []
|
||||
XCTAssertTrue(a.ends(with: empty, by: areEquivalent))
|
||||
}
|
||||
|
||||
func testEmptyEndsWithEmpty() {
|
||||
let empty: [NotEquatable<Int>] = []
|
||||
XCTAssertTrue(empty.ends(with: empty, by: areEquivalent))
|
||||
}
|
||||
|
||||
func testEmptyDoesNotEndWithNonempty() {
|
||||
XCTAssertFalse([].ends(with: nonEq(1...10), by: areEquivalent))
|
||||
}
|
||||
|
||||
private func nonEq(_ range: ClosedRange<Int>) -> [NotEquatable<Int>] {
|
||||
range.map(NotEquatable.init)
|
||||
}
|
||||
|
||||
private func areEquivalent<T: Equatable>(
|
||||
lhs: NotEquatable<T>, rhs: NotEquatable<T>
|
||||
) -> Bool {
|
||||
lhs.value == rhs.value
|
||||
}
|
||||
|
||||
private struct NotEquatable<T> {
|
||||
let value: T
|
||||
}
|
||||
}
|
||||
@@ -9,8 +9,8 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class FirstNonNilTests: XCTestCase {
|
||||
func testFirstNonNil() {
|
||||
|
||||
@@ -9,11 +9,11 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class GroupedTests: XCTestCase {
|
||||
private class SampleError: Error {}
|
||||
private final class SampleError: Error {}
|
||||
|
||||
// Based on https://github.com/apple/swift/blob/4d1d8a9de5ebc132a17aee9fc267461facf89bf8/validation-test/stdlib/Dictionary.swift#L1974-L1988
|
||||
|
||||
|
||||
@@ -9,8 +9,8 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class IndexedTests: XCTestCase {
|
||||
func testIndexed() {
|
||||
@@ -27,8 +27,8 @@ final class IndexedTests: XCTestCase {
|
||||
let indexOfI = si.last(where: { $0.element == "I" })!.index
|
||||
XCTAssertEqual("I", s[indexOfI])
|
||||
}
|
||||
|
||||
|
||||
func testIndexedLazy() {
|
||||
XCTAssertLazyCollection("ABCD".lazy.indexed())
|
||||
requireLazyCollection("ABCD".lazy.indexed())
|
||||
}
|
||||
}
|
||||
@@ -10,49 +10,50 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
|
||||
@testable import Algorithms
|
||||
|
||||
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])
|
||||
expectEqualSequences(interspersed, [1, 0, 2, 0, 3, 0, 4, 0, 5])
|
||||
}
|
||||
|
||||
func testSequenceEmpty() {
|
||||
let interspersed = (1...).prefix(0).interspersed(with: 0)
|
||||
XCTAssertEqualSequences(interspersed, [])
|
||||
expectEqualSequences(interspersed, [])
|
||||
}
|
||||
|
||||
func testString() {
|
||||
let interspersed = "ABCDE".interspersed(with: "-")
|
||||
XCTAssertEqualSequences(interspersed, "A-B-C-D-E")
|
||||
expectEqualSequences(interspersed, "A-B-C-D-E")
|
||||
}
|
||||
|
||||
func testStringEmpty() {
|
||||
let interspersed = "".interspersed(with: "-")
|
||||
XCTAssertEqualSequences(interspersed, "")
|
||||
expectEqualSequences(interspersed, "")
|
||||
}
|
||||
|
||||
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)
|
||||
expectEqualSequences(interspersed, [1, 0, 2, 0, 3, 0, 4])
|
||||
}
|
||||
|
||||
func testArrayEmpty() {
|
||||
let interspersed = [].interspersed(with: 0)
|
||||
XCTAssertEqualSequences(interspersed, [])
|
||||
expectEqualSequences(interspersed, [])
|
||||
}
|
||||
|
||||
func testCollection() {
|
||||
let interspersed = ["A","B","C","D"].interspersed(with: "-")
|
||||
let interspersed = ["A", "B", "C", "D"].interspersed(with: "-")
|
||||
XCTAssertEqual(interspersed.count, 7)
|
||||
}
|
||||
|
||||
func testBidirectionalCollection() {
|
||||
let reversed = "ABCDE".interspersed(with: "-").reversed()
|
||||
XCTAssertEqualSequences(reversed, "E-D-C-B-A")
|
||||
expectEqualSequences(reversed, "E-D-C-B-A")
|
||||
}
|
||||
|
||||
|
||||
func testIndexTraversals() {
|
||||
let validator = IndexValidator<InterspersedSequence<String>>()
|
||||
validator.validate("".interspersed(with: "-"), expectedCount: 0)
|
||||
@@ -62,42 +63,44 @@ final class IntersperseTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testIntersperseLazy() {
|
||||
XCTAssertLazySequence((1...).prefix(0).lazy.interspersed(with: 0))
|
||||
XCTAssertLazyCollection("ABCDE".lazy.interspersed(with: "-"))
|
||||
requireLazySequence((1...).prefix(0).lazy.interspersed(with: 0))
|
||||
requireLazyCollection("ABCDE".lazy.interspersed(with: "-"))
|
||||
}
|
||||
|
||||
|
||||
func testInterspersedMap() {
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
(0..<0).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
|
||||
[])
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
|
||||
expectEqualSequences(
|
||||
(0..<1).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
|
||||
[0])
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
|
||||
expectEqualSequences(
|
||||
(0..<5).lazy.interspersedMap({ $0 }, with: { $0 + $1 + 100 }),
|
||||
[0, 101, 1, 103, 2, 105, 3, 107, 4])
|
||||
}
|
||||
|
||||
|
||||
func testInterspersedMapLazy() {
|
||||
XCTAssertLazySequence(AnySequence([]).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }))
|
||||
XCTAssertLazyCollection((0..<0).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }))
|
||||
requireLazySequence(
|
||||
AnySequence([]).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }))
|
||||
requireLazyCollection(
|
||||
(0..<0).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }))
|
||||
}
|
||||
|
||||
|
||||
func testInterspersedMapIndexTraversals() {
|
||||
let validator = IndexValidator<InterspersedMapSequence<Range<Int>, Int>>()
|
||||
validator.validate(
|
||||
(0..<0).lazy.interspersedMap({ $0 }, with: {_, _ in 100 }),
|
||||
(0..<0).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
|
||||
expectedCount: 0)
|
||||
validator.validate(
|
||||
(0..<1).lazy.interspersedMap({ $0 }, with: {_, _ in 100 }),
|
||||
(0..<1).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
|
||||
expectedCount: 1)
|
||||
validator.validate(
|
||||
(0..<2).lazy.interspersedMap({ $0 }, with: {_, _ in 100 }),
|
||||
(0..<2).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
|
||||
expectedCount: 3)
|
||||
validator.validate(
|
||||
(0..<5).lazy.interspersedMap({ $0 }, with: {_, _ in 100 }),
|
||||
(0..<5).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
|
||||
expectedCount: 9)
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
|
||||
@testable import Algorithms
|
||||
|
||||
final class JoinedTests: XCTestCase {
|
||||
@@ -21,110 +22,124 @@ final class JoinedTests: XCTestCase {
|
||||
["foo", "bar"],
|
||||
["", "", "foo", "", "bar", "baz", ""],
|
||||
]
|
||||
|
||||
|
||||
func testJoined() {
|
||||
let expected = ["", "", "", "foo", "foobar", "foobarbaz"]
|
||||
|
||||
|
||||
for (strings, expected) in zip(stringArrays, expected) {
|
||||
// regular sequence
|
||||
XCTAssertEqualSequences(AnySequence(strings).joined(), expected)
|
||||
|
||||
expectEqualSequences(AnySequence(strings).joined(), expected)
|
||||
|
||||
// lazy sequence
|
||||
XCTAssertEqualSequences(AnySequence(strings).lazy.joined(), expected)
|
||||
|
||||
expectEqualSequences(AnySequence(strings).lazy.joined(), expected)
|
||||
|
||||
// regular collection
|
||||
XCTAssertEqualSequences(strings.joined(), expected)
|
||||
|
||||
expectEqualSequences(strings.joined(), expected)
|
||||
|
||||
// lazy collection
|
||||
XCTAssertEqualSequences(strings.lazy.joined() as FlattenCollection, expected)
|
||||
expectEqualSequences(
|
||||
strings.lazy.joined() as FlattenCollection, expected)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testJoinedByElement() {
|
||||
let separator: Character = " "
|
||||
let expected = ["", "", " ", "foo", "foo bar", " foo bar baz "]
|
||||
|
||||
|
||||
for (strings, expected) in zip(stringArrays, expected) {
|
||||
XCTAssertEqualSequences(AnySequence(strings).joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(AnySequence(strings).lazy.joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(strings.joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(strings.lazy.joined(by: separator), expected)
|
||||
expectEqualSequences(
|
||||
AnySequence(strings).joined(by: separator), expected)
|
||||
expectEqualSequences(
|
||||
AnySequence(strings).lazy.joined(by: separator), expected)
|
||||
expectEqualSequences(strings.joined(by: separator), expected)
|
||||
expectEqualSequences(strings.lazy.joined(by: separator), expected)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testJoinedBySequence() {
|
||||
let separator = ", "
|
||||
let expected = ["", "", ", ", "foo", "foo, bar", ", , foo, , bar, baz, "]
|
||||
|
||||
|
||||
for (strings, expected) in zip(stringArrays, expected) {
|
||||
XCTAssertEqualSequences(AnySequence(strings).joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(AnySequence(strings).lazy.joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(strings.joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(strings.lazy.joined(by: separator), expected)
|
||||
expectEqualSequences(
|
||||
AnySequence(strings).joined(by: separator), expected)
|
||||
expectEqualSequences(
|
||||
AnySequence(strings).lazy.joined(by: separator), expected)
|
||||
expectEqualSequences(strings.joined(by: separator), expected)
|
||||
expectEqualSequences(strings.lazy.joined(by: separator), expected)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testJoinedByElementClosure() {
|
||||
let separator = { (left: String, right: String) -> Character in
|
||||
left.isEmpty || right.isEmpty ? " " : "-"
|
||||
}
|
||||
|
||||
|
||||
let expected = ["", "", " ", "foo", "foo-bar", " foo bar-baz "]
|
||||
|
||||
|
||||
for (strings, expected) in zip(stringArrays, expected) {
|
||||
XCTAssertEqualSequences(AnySequence(strings).joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(AnySequence(strings).lazy.joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(strings.joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(strings.lazy.joined(by: separator), expected)
|
||||
expectEqualSequences(
|
||||
AnySequence(strings).joined(by: separator), expected)
|
||||
expectEqualSequences(
|
||||
AnySequence(strings).lazy.joined(by: separator), expected)
|
||||
expectEqualSequences(strings.joined(by: separator), expected)
|
||||
expectEqualSequences(strings.lazy.joined(by: separator), expected)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testJoinedBySequenceClosure() {
|
||||
let separator = { (left: String, right: String) in
|
||||
"(\(left.count), \(right.count))"
|
||||
}
|
||||
|
||||
|
||||
let expected = [
|
||||
"",
|
||||
"",
|
||||
"(0, 0)",
|
||||
"foo",
|
||||
"foo(3, 3)bar",
|
||||
"(0, 0)(0, 3)foo(3, 0)(0, 3)bar(3, 3)baz(3, 0)"
|
||||
"(0, 0)(0, 3)foo(3, 0)(0, 3)bar(3, 3)baz(3, 0)",
|
||||
]
|
||||
|
||||
|
||||
for (strings, expected) in zip(stringArrays, expected) {
|
||||
XCTAssertEqualSequences(AnySequence(strings).joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(AnySequence(strings).lazy.joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(strings.joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(strings.lazy.joined(by: separator), expected)
|
||||
expectEqualSequences(
|
||||
AnySequence(strings).joined(by: separator), expected)
|
||||
expectEqualSequences(
|
||||
AnySequence(strings).lazy.joined(by: separator), expected)
|
||||
expectEqualSequences(strings.joined(by: separator), expected)
|
||||
expectEqualSequences(strings.lazy.joined(by: separator), expected)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testJoinedLazy() {
|
||||
XCTAssertLazySequence(AnySequence([[1], [2]]).lazy.joined())
|
||||
XCTAssertLazySequence(AnySequence([[1], [2]]).lazy.joined(by: 1))
|
||||
XCTAssertLazySequence(AnySequence([[1], [2]]).lazy.joined(by: { _, _ in 1 }))
|
||||
XCTAssertLazyCollection([[1], [2]].lazy.joined())
|
||||
XCTAssertLazyCollection([[1], [2]].lazy.joined(by: 1))
|
||||
XCTAssertLazyCollection([[1], [2]].lazy.joined(by: { _, _ in 1 }))
|
||||
requireLazySequence(AnySequence([[1], [2]]).lazy.joined())
|
||||
requireLazySequence(AnySequence([[1], [2]]).lazy.joined(by: 1))
|
||||
requireLazySequence(
|
||||
AnySequence([[1], [2]]).lazy.joined(by: { _, _ in 1 }))
|
||||
requireLazyCollection([[1], [2]].lazy.joined())
|
||||
requireLazyCollection([[1], [2]].lazy.joined(by: 1))
|
||||
requireLazyCollection([[1], [2]].lazy.joined(by: { _, _ in 1 }))
|
||||
}
|
||||
|
||||
|
||||
func testJoinedIndexTraversals() {
|
||||
let validator = IndexValidator<FlattenCollection<[String]>>()
|
||||
|
||||
|
||||
// the last test case takes too long to run
|
||||
for strings in stringArrays.dropLast() {
|
||||
validator.validate(strings.joined() as FlattenCollection)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testJoinedByIndexTraversals() {
|
||||
let validator1 = IndexValidator<JoinedByCollection<[String], String>>()
|
||||
let validator2 = IndexValidator<JoinedByClosureCollection<[String], String>>()
|
||||
|
||||
let validator2 = IndexValidator<
|
||||
JoinedByClosureCollection<[String], String>
|
||||
>()
|
||||
|
||||
// the last test case takes too long to run
|
||||
for (strings, separator) in product(stringArrays.dropLast(), ["", " ", ", "]) {
|
||||
for (strings, separator) in product(
|
||||
stringArrays.dropLast(), ["", " ", ", "])
|
||||
{
|
||||
validator1.validate(strings.joined(by: separator))
|
||||
validator2.validate(strings.lazy.joined(by: { _, _ in separator }))
|
||||
}
|
||||
|
||||
@@ -9,11 +9,11 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class KeyedTests: XCTestCase {
|
||||
private class SampleError: Error {}
|
||||
private final class SampleError: Error {}
|
||||
|
||||
func testUniqueKeys() {
|
||||
let d = ["Apple", "Banana", "Cherry"].keyed(by: { $0.first! })
|
||||
@@ -32,13 +32,16 @@ final class KeyedTests: XCTestCase {
|
||||
func testNonUniqueKeys() throws {
|
||||
let d = ["Apple", "Avocado", "Banana", "Cherry"].keyed(by: { $0.first! })
|
||||
XCTAssertEqual(d.count, 3)
|
||||
XCTAssertEqual(d["A"]!, "Avocado", "On a key-collision, keyed(by:) should take the latest value.")
|
||||
XCTAssertEqual(
|
||||
d["A"]!, "Avocado",
|
||||
"On a key-collision, keyed(by:) should take the latest value.")
|
||||
XCTAssertEqual(d["B"]!, "Banana")
|
||||
XCTAssertEqual(d["C"]!, "Cherry")
|
||||
}
|
||||
|
||||
func testNonUniqueKeysWithMergeFunction() {
|
||||
var resolveCallHistory = [(key: Character, current: String, new: String)]()
|
||||
var resolveCallHistory: [(key: Character, current: String, new: String)] =
|
||||
[]
|
||||
let expectedCallHistory = [
|
||||
(key: "A", current: "Apple", new: "Avocado"),
|
||||
(key: "C", current: "Cherry", new: "Coconut"),
|
||||
@@ -58,8 +61,9 @@ final class KeyedTests: XCTestCase {
|
||||
XCTAssertEqual(d["C"]!, "Cherry-Coconut")
|
||||
XCTAssertNil(d["D"])
|
||||
|
||||
// Quick/dirty workaround: tuples aren't Equatable
|
||||
XCTAssertEqual(
|
||||
resolveCallHistory.map(String.init(describing:)), // quick/dirty workaround: tuples aren't Equatable
|
||||
resolveCallHistory.map(String.init(describing:)),
|
||||
expectedCallHistory.map(String.init(describing:))
|
||||
)
|
||||
}
|
||||
@@ -80,7 +84,8 @@ final class KeyedTests: XCTestCase {
|
||||
let error = SampleError()
|
||||
|
||||
XCTAssertThrowsError(
|
||||
try input.keyed(by: { $0.first! }, resolvingConflictsWith: { _, _, _ in throw error })
|
||||
try input.keyed(
|
||||
by: { $0.first! }, resolvingConflictsWith: { _, _, _ in throw error })
|
||||
) { thrownError in
|
||||
XCTAssertIdentical(error, thrownError as? SampleError)
|
||||
}
|
||||
|
||||
@@ -9,41 +9,41 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class SortedPrefixTests: XCTestCase {
|
||||
func testMinCount() {
|
||||
// Replacement at start and end
|
||||
let input = [10, 11, 12, 1, 13, 2, 14, 3, 4, 5, 6, 0, 7, 8, 9]
|
||||
let min = input.min(count: 5)
|
||||
XCTAssertEqualSequences(min, 0..<5)
|
||||
expectEqualSequences(min, 0..<5)
|
||||
|
||||
// Stability with all equal values
|
||||
let maxZeroes = Array(repeating: 0, count: 100)
|
||||
.enumerated()
|
||||
.max(count: 5, sortedBy: { $0.element < $1.element })
|
||||
XCTAssertEqualSequences(maxZeroes.map { $0.offset }, 95..<100)
|
||||
expectEqualSequences(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]
|
||||
let max = input.max(count: 5)
|
||||
XCTAssertEqualSequences(max, 10..<15)
|
||||
expectEqualSequences(max, 10..<15)
|
||||
|
||||
// Stability with all equal values
|
||||
let maxZeroes = Array(repeating: 0, count: 100)
|
||||
.enumerated()
|
||||
.max(count: 5, sortedBy: { $0.element < $1.element })
|
||||
XCTAssertEqualSequences(maxZeroes.map { $0.offset }, 95..<100)
|
||||
expectEqualSequences(maxZeroes.map { $0.offset }, 95..<100)
|
||||
}
|
||||
|
||||
|
||||
func testEmpty() {
|
||||
let array = [Int]()
|
||||
let array: [Int] = []
|
||||
XCTAssertEqual(array.min(count: 0), [])
|
||||
XCTAssertEqual(array.min(count: 100), [])
|
||||
|
||||
|
||||
XCTAssertEqual(array.max(count: 0), [])
|
||||
XCTAssertEqual(array.max(count: 100), [])
|
||||
}
|
||||
@@ -51,23 +51,23 @@ 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)
|
||||
|
||||
expectEqualSequences(seq.min(count: 0), [])
|
||||
expectEqualSequences(seq.min(count: 5), 1...5)
|
||||
|
||||
expectEqualSequences(seq.max(count: 0), [])
|
||||
expectEqualSequences(seq.max(count: 5), 96...100)
|
||||
}
|
||||
|
||||
|
||||
func testSortedPrefixComparable() {
|
||||
let array: [Int] = [20, 1, 4, 70, 100, 2, 3, 7, 90]
|
||||
|
||||
XCTAssertEqual(array.min(count: 0), [])
|
||||
XCTAssertEqual(array.min(count: 1), [1])
|
||||
XCTAssertEqualSequences(array.min(count: 5), array.sorted().prefix(5))
|
||||
expectEqualSequences(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])
|
||||
@@ -83,20 +83,20 @@ final class SortedPrefixTests: XCTestCase {
|
||||
XCTAssertEqual(input.min(count: 1, sortedBy: <), [range.lowerBound])
|
||||
XCTAssertEqual(input.min(count: 1, sortedBy: >), [range.upperBound])
|
||||
|
||||
XCTAssertEqualSequences(input.min(count: 5, sortedBy: <), range.prefix(5))
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(input.min(count: 5, sortedBy: <), range.prefix(5))
|
||||
expectEqualSequences(
|
||||
input.min(count: 5, sortedBy: >),
|
||||
range.suffix(5).reversed())
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
input.min(count: 500, sortedBy: <),
|
||||
range.prefix(500))
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
input.min(count: 500, sortedBy: >),
|
||||
range.suffix(500).reversed())
|
||||
|
||||
XCTAssertEqualSequences(input.min(count: 1000, sortedBy: <), range)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(input.min(count: 1000, sortedBy: <), range)
|
||||
expectEqualSequences(
|
||||
input.min(count: 1000, sortedBy: >),
|
||||
range.reversed())
|
||||
}
|
||||
@@ -111,52 +111,60 @@ final class SortedPrefixTests: XCTestCase {
|
||||
XCTAssertEqual(input.max(count: 1, sortedBy: <), [range.upperBound])
|
||||
XCTAssertEqual(input.max(count: 1, sortedBy: >), [range.lowerBound])
|
||||
|
||||
XCTAssertEqualSequences(input.max(count: 5, sortedBy: <), range.suffix(5))
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(input.max(count: 5, sortedBy: <), range.suffix(5))
|
||||
expectEqualSequences(
|
||||
input.max(count: 5, sortedBy: >),
|
||||
range.prefix(5).reversed())
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
input.max(count: 500, sortedBy: <),
|
||||
range.suffix(500))
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
input.max(count: 500, sortedBy: >),
|
||||
range.prefix(500).reversed())
|
||||
|
||||
XCTAssertEqualSequences(input.max(count: 1000, sortedBy: <), range)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(input.max(count: 1000, sortedBy: <), range)
|
||||
expectEqualSequences(
|
||||
input.max(count: 1000, sortedBy: >),
|
||||
range.reversed())
|
||||
}
|
||||
|
||||
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)
|
||||
assertStability(Array(repeating: 0, count: 100), withCount: 5)
|
||||
assertStability(Array(repeating: 0, count: 100), withCount: 20)
|
||||
assertStability(Array(repeating: 0, count: 100), withCount: 100)
|
||||
assertStability(Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50), withCount: 2)
|
||||
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(
|
||||
Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50),
|
||||
withCount: 2)
|
||||
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)
|
||||
}
|
||||
|
||||
func assertStability(
|
||||
@@ -165,19 +173,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 }
|
||||
|
||||
@@ -1,68 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
|
||||
final class PDQSortTests: XCTestCase {
|
||||
func testPartitionLeft() {
|
||||
for _ in 1...1000 {
|
||||
var a = (0...20).map { _ in Int.random(in: 1...5) }
|
||||
a._preparePivot(subrange: a.indices, count: a.indices.count, by: <)
|
||||
let pivot = a._partitionLeft(subrange: a.indices, by: <)
|
||||
for x in a[..<pivot] {
|
||||
XCTAssertLessThanOrEqual(x, a[pivot])
|
||||
}
|
||||
for x in a[(pivot + 1)...] {
|
||||
XCTAssertGreaterThan(x, a[pivot])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testPartitionRight() {
|
||||
for _ in 1...1000 {
|
||||
var a = (0...20).map { _ in Int.random(in: 1...5) }
|
||||
a._preparePivot(subrange: a.indices, count: a.indices.count, by: <)
|
||||
let (pivot, _) = a._partitionRight(subrange: a.indices, by: <)
|
||||
for x in a[..<pivot] {
|
||||
XCTAssertLessThan(x, a[pivot])
|
||||
}
|
||||
for x in a[(pivot + 1)...] {
|
||||
XCTAssertGreaterThanOrEqual(x, a[pivot])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testSort() {
|
||||
var empty: [Int] = []
|
||||
empty.sortUnstable()
|
||||
|
||||
var inOrder = Array(1...1000)
|
||||
inOrder.sortUnstable()
|
||||
XCTAssert(inOrder.isSorted())
|
||||
|
||||
var reversed = Array((1...1000).reversed())
|
||||
reversed.sortUnstable()
|
||||
XCTAssert(reversed.isSorted())
|
||||
|
||||
for _ in 1...1000 {
|
||||
var a = (0...Int.random(in: 100...1000)).map { _ in Int.random(in: 1...50) }
|
||||
a.sortUnstable()
|
||||
XCTAssert(a.isSorted())
|
||||
}
|
||||
}
|
||||
|
||||
func testSpecialCase() {
|
||||
var a = (1...10).shuffled() + [20] + (31...40).shuffled()
|
||||
a.sortUnstable()
|
||||
XCTAssert(a.isSorted())
|
||||
}
|
||||
}
|
||||
@@ -9,8 +9,8 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class PartitionTests: XCTestCase {
|
||||
func testStablePartition() {
|
||||
@@ -30,17 +30,17 @@ final class PartitionTests: XCTestCase {
|
||||
|
||||
var b = a
|
||||
var r = b[p..<q].stablePartition(by: f)
|
||||
XCTAssertEqualSequences(b[..<p], prefix)
|
||||
XCTAssertEqualSequences(b[q...], suffix)
|
||||
XCTAssertEqualSequences(b[p..<r], subrange.filter(notf))
|
||||
XCTAssertEqualSequences(b[r..<q], subrange.filter(f))
|
||||
expectEqualSequences(b[..<p], prefix)
|
||||
expectEqualSequences(b[q...], suffix)
|
||||
expectEqualSequences(b[p..<r], subrange.filter(notf))
|
||||
expectEqualSequences(b[r..<q], subrange.filter(f))
|
||||
|
||||
b = a
|
||||
r = b[p..<q].stablePartition(by: notf)
|
||||
XCTAssertEqualSequences(b[..<p], prefix)
|
||||
XCTAssertEqualSequences(b[q...], suffix)
|
||||
XCTAssertEqualSequences(b[p..<r], subrange.filter(f))
|
||||
XCTAssertEqualSequences(b[r..<q], subrange.filter(notf))
|
||||
expectEqualSequences(b[..<p], prefix)
|
||||
expectEqualSequences(b[q...], suffix)
|
||||
expectEqualSequences(b[p..<r], subrange.filter(f))
|
||||
expectEqualSequences(b[r..<q], subrange.filter(notf))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -49,18 +49,18 @@ final class PartitionTests: XCTestCase {
|
||||
let notf = { !f($0) }
|
||||
var b = a
|
||||
var r = b.stablePartition(by: f)
|
||||
XCTAssertEqualSequences(b[..<r], a.filter(notf))
|
||||
XCTAssertEqualSequences(b[r...], a.filter(f))
|
||||
expectEqualSequences(b[..<r], a.filter(notf))
|
||||
expectEqualSequences(b[r...], a.filter(f))
|
||||
|
||||
b = a
|
||||
r = b.stablePartition(by: notf)
|
||||
XCTAssertEqualSequences(b[..<r], a.filter(f))
|
||||
XCTAssertEqualSequences(b[r...], a.filter(notf))
|
||||
expectEqualSequences(b[..<r], a.filter(f))
|
||||
expectEqualSequences(b[r...], a.filter(notf))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testStablePartitionWithSubrange() {
|
||||
for length in 10...20 {
|
||||
let a = Array(0..<length)
|
||||
@@ -72,13 +72,17 @@ 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))
|
||||
expectEqualSequences(
|
||||
b[partitionRange.lowerBound..<p],
|
||||
a[partitionRange].filter { !condition($0) })
|
||||
expectEqualSequences(
|
||||
b[p..<partitionRange.upperBound],
|
||||
a[partitionRange].filter(condition))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testPartitioningIndex() {
|
||||
for i in 0..<7 {
|
||||
for j in i..<11 {
|
||||
@@ -91,27 +95,27 @@ final class PartitionTests: XCTestCase {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testPartitioningIndexWithEmptyInput() {
|
||||
let input: [Int] = []
|
||||
|
||||
let a = input.partitioningIndex(where: { _ in return true })
|
||||
|
||||
let a = input.partitioningIndex(where: { _ in true })
|
||||
XCTAssertEqual(a, input.startIndex)
|
||||
|
||||
let b = input.partitioningIndex(where: { _ in return false })
|
||||
|
||||
let b = input.partitioningIndex(where: { _ in false })
|
||||
XCTAssertEqual(b, input.endIndex)
|
||||
}
|
||||
|
||||
|
||||
func testPartitioningIndexWithOneEmptyPartition() {
|
||||
let input: Range<Int> = (0 ..< 10)
|
||||
|
||||
let input: Range<Int> = (0..<10)
|
||||
|
||||
let a = input.partitioningIndex(where: { $0 > 10 })
|
||||
XCTAssertEqual(a, input.endIndex)
|
||||
|
||||
|
||||
let b = input.partitioningIndex(where: { $0 >= 0 })
|
||||
XCTAssertEqual(b, input.startIndex)
|
||||
}
|
||||
|
||||
|
||||
func testPartitionWithSubrangeBidirectionalCollection() {
|
||||
for length in 10...20 {
|
||||
let a = Array(0..<length)
|
||||
@@ -121,10 +125,14 @@ 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))
|
||||
expectEqualSequences(
|
||||
b[partitionRange.lowerBound..<p],
|
||||
a[partitionRange].filter { !condition($0) })
|
||||
expectUnorderedEqualSequences(
|
||||
b[p..<partitionRange.upperBound],
|
||||
a[partitionRange].filter(condition))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -141,51 +149,59 @@ 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))
|
||||
|
||||
expectEqualSequences(
|
||||
b[partitionRange.lowerBound..<p],
|
||||
a[partitionRange].filter { !condition($0) })
|
||||
expectUnorderedEqualSequences(
|
||||
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])
|
||||
expectEqualSequences(
|
||||
b[partitionRange.lowerBound..<p],
|
||||
bdc[partitionRange.lowerBound..<bdcp])
|
||||
expectUnorderedEqualSequences(
|
||||
b[p..<partitionRange.upperBound],
|
||||
bdc[bdcp..<partitionRange.upperBound])
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testPartitionedWithEmptyInput() {
|
||||
let input: [Int] = []
|
||||
|
||||
let s0 = input.partitioned(by: { _ in return true })
|
||||
|
||||
|
||||
let s0 = input.partitioned(by: { _ in true })
|
||||
|
||||
XCTAssertTrue(s0.0.isEmpty)
|
||||
XCTAssertTrue(s0.1.isEmpty)
|
||||
}
|
||||
|
||||
/// Test the example given in the `partitioned(by:)` documentation
|
||||
|
||||
/// Test the example given in the `partitioned(by:)` documentation.
|
||||
func testPartitionedExample() throws {
|
||||
let cast = ["Vivien", "Marlon", "Kim", "Karl"]
|
||||
let (longNames, shortNames) = cast.partitioned(by: { $0.count < 5 })
|
||||
XCTAssertEqual(longNames, ["Vivien", "Marlon"])
|
||||
XCTAssertEqual(shortNames, ["Kim", "Karl"])
|
||||
}
|
||||
|
||||
|
||||
func testPartitionedWithPredicate() throws {
|
||||
let s0 = ["A", "B", "C", "D"].partitioned(by: { $0 == $0.lowercased() })
|
||||
let s1 = ["a", "B", "C", "D"].partitioned(by: { $0 == $0.lowercased() })
|
||||
let s2 = ["a", "B", "c", "D"].partitioned(by: { $0 == $0.lowercased() })
|
||||
let s3 = ["a", "B", "c", "d"].partitioned(by: { $0 == $0.lowercased() })
|
||||
|
||||
|
||||
XCTAssertEqual(s0.0, ["A", "B", "C", "D"])
|
||||
XCTAssertEqual(s0.1, [])
|
||||
|
||||
|
||||
XCTAssertEqual(s1.0, ["B", "C", "D"])
|
||||
XCTAssertEqual(s1.1, ["a"])
|
||||
|
||||
|
||||
XCTAssertEqual(s2.0, ["B", "D"])
|
||||
XCTAssertEqual(s2.1, ["a", "c"])
|
||||
|
||||
|
||||
XCTAssertEqual(s3.0, ["B"])
|
||||
XCTAssertEqual(s3.1, ["a", "c", "d"])
|
||||
}
|
||||
|
||||
@@ -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))
|
||||
expectEqualSequences(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))
|
||||
requireLazySequence("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],
|
||||
])
|
||||
expectEqualSequences(
|
||||
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],
|
||||
])
|
||||
expectEqualSequences(
|
||||
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],
|
||||
])
|
||||
expectEqualSequences(
|
||||
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],
|
||||
])
|
||||
expectEqualSequences(
|
||||
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"],
|
||||
])
|
||||
expectEqualSequences(
|
||||
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"],
|
||||
])
|
||||
expectEqualSequences(
|
||||
permutations,
|
||||
[
|
||||
["Alex"],
|
||||
["Celeste"],
|
||||
["Davide"],
|
||||
["Alex", "Celeste"],
|
||||
["Alex", "Davide"],
|
||||
["Celeste", "Alex"],
|
||||
["Celeste", "Davide"],
|
||||
["Davide", "Alex"],
|
||||
["Davide", "Celeste"],
|
||||
])
|
||||
}
|
||||
}
|
||||
@@ -10,34 +10,35 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
|
||||
@testable import Algorithms
|
||||
|
||||
final class ProductTests: XCTestCase {
|
||||
func testProduct() {
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
[(1, "A" as Character), (1, "B"), (2, "A"), (2, "B")],
|
||||
product(1...2, "AB"),
|
||||
by: ==)
|
||||
|
||||
XCTAssertEqualSequences(product(1...10, ""), [], by: ==)
|
||||
XCTAssertEqualSequences(product("", 1...10), [], by: ==)
|
||||
expectEqualSequences(product(1...10, ""), [], by: ==)
|
||||
expectEqualSequences(product("", 1...10), [], by: ==)
|
||||
}
|
||||
|
||||
|
||||
func testProductReversed() {
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
[(2, "B" as Character), (2, "A"), (1, "B"), (1, "A")],
|
||||
product(1...2, "AB").reversed(),
|
||||
by: ==)
|
||||
|
||||
XCTAssertEqualSequences(product(1...10, "").reversed(), [], by: ==)
|
||||
XCTAssertEqualSequences(product("", 1...10).reversed(), [], by: ==)
|
||||
expectEqualSequences(product(1...10, "").reversed(), [], by: ==)
|
||||
expectEqualSequences(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() {
|
||||
let validator = IndexValidator<Product2Sequence<[Int], String>>(
|
||||
indicesIncludingEnd: { product in
|
||||
@@ -47,7 +48,7 @@ final class ProductTests: XCTestCase {
|
||||
}
|
||||
} + [.init(i1: product.base1.endIndex, i2: product.base2.startIndex)]
|
||||
})
|
||||
|
||||
|
||||
validator.validate(product([1, 2, 3, 4], "abc"), expectedCount: 4 * 3)
|
||||
validator.validate(product([1, 2, 3, 4], ""), expectedCount: 4 * 0)
|
||||
validator.validate(product([], "abc"), expectedCount: 0 * 3)
|
||||
|
||||
@@ -10,16 +10,18 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
|
||||
@testable import Algorithms
|
||||
|
||||
func validateRandomSamples<S: Sequence>(
|
||||
_ samples: [Int: Int],
|
||||
elements: S,
|
||||
expectedValue: Int,
|
||||
file: StaticString = #file, line: UInt = #line
|
||||
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)
|
||||
expectEqualSequences(
|
||||
samples.keys.sorted(), elements,
|
||||
file: file, line: line)
|
||||
for v in samples.values {
|
||||
XCTAssert(expectedRange.contains(v), file: file, line: line)
|
||||
@@ -41,41 +43,44 @@ final class RandomSampleTests: XCTestCase {
|
||||
result[x, default: 0] += 1
|
||||
}
|
||||
}
|
||||
validateRandomSamples(samples, elements: c, expectedValue: (k * iterations) / n)
|
||||
validateRandomSamples(
|
||||
samples, elements: c, expectedValue: (k * iterations) / n)
|
||||
}
|
||||
|
||||
|
||||
func testRandomSampleCollection() {
|
||||
let samples: [Int: Int] = (0..<iterations).reduce(into: [:]) { result, _ in
|
||||
for x in c.randomSample(count: k) {
|
||||
result[x, default: 0] += 1
|
||||
}
|
||||
}
|
||||
validateRandomSamples(samples, elements: c, expectedValue: (k * iterations) / n)
|
||||
validateRandomSamples(
|
||||
samples, elements: c, expectedValue: (k * iterations) / n)
|
||||
}
|
||||
|
||||
|
||||
func testRandomSampleSequence() {
|
||||
let samples: [Int: Int] = (0..<iterations).reduce(into: [:]) { result, _ in
|
||||
for x in s.randomSample(count: k) {
|
||||
result[x, default: 0] += 1
|
||||
}
|
||||
}
|
||||
validateRandomSamples(samples, elements: s, expectedValue: (k * iterations) / n)
|
||||
validateRandomSamples(
|
||||
samples, elements: s, expectedValue: (k * iterations) / n)
|
||||
}
|
||||
|
||||
|
||||
func testRandomSampleEdgeCases() {
|
||||
XCTAssert(c.randomStableSample(count: 0).isEmpty)
|
||||
XCTAssertEqualSequences(c.randomStableSample(count: n), c)
|
||||
XCTAssertEqualSequences(c.randomStableSample(count: n * 2), c)
|
||||
expectEqualSequences(c.randomStableSample(count: n), c)
|
||||
expectEqualSequences(c.randomStableSample(count: n * 2), c)
|
||||
|
||||
XCTAssert(c.randomSample(count: 0).isEmpty)
|
||||
XCTAssertEqualSequences(c.randomSample(count: n).sorted(), c)
|
||||
XCTAssertEqualSequences(c.randomSample(count: n * 2).sorted(), c)
|
||||
|
||||
expectEqualSequences(c.randomSample(count: n).sorted(), c)
|
||||
expectEqualSequences(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)
|
||||
expectEqualSequences(s.randomSample(count: n).sorted(), c)
|
||||
expectEqualSequences(s.randomSample(count: n * 2).sorted(), c)
|
||||
}
|
||||
|
||||
|
||||
func testRandomSampleRepeatable() {
|
||||
var generator = SplitMix64(seed: 0)
|
||||
let sample1a = c.randomSample(count: k, using: &generator)
|
||||
@@ -88,7 +93,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 +106,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 +124,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 {
|
||||
struct TestError: Error {}
|
||||
@@ -18,23 +18,26 @@ final class ReductionsTests: XCTestCase {
|
||||
// MARK: - Exclusive Reductions
|
||||
|
||||
func testExclusiveLazy() {
|
||||
XCTAssertEqualSequences((1...).prefix(4).lazy.reductions(0, +), [0, 1, 3, 6, 10])
|
||||
XCTAssertEqualSequences((1...).prefix(1).lazy.reductions(0, +), [0, 1])
|
||||
XCTAssertEqualSequences((1...).prefix(0).lazy.reductions(0, +), [0])
|
||||
expectEqualSequences(
|
||||
(1...).prefix(4).lazy.reductions(0, +), [0, 1, 3, 6, 10])
|
||||
expectEqualSequences((1...).prefix(1).lazy.reductions(0, +), [0, 1])
|
||||
expectEqualSequences((1...).prefix(0).lazy.reductions(0, +), [0])
|
||||
|
||||
XCTAssertEqualCollections([1, 2, 3, 4].lazy.reductions(0, +), [0, 1, 3, 6, 10])
|
||||
XCTAssertEqualCollections([1].lazy.reductions(0, +), [0, 1])
|
||||
XCTAssertEqualCollections(EmptyCollection<Int>().lazy.reductions(0, +), [0])
|
||||
expectEqualCollections(
|
||||
[1, 2, 3, 4].lazy.reductions(0, +), [0, 1, 3, 6, 10])
|
||||
expectEqualCollections([1].lazy.reductions(0, +), [0, 1])
|
||||
expectEqualCollections(EmptyCollection<Int>().lazy.reductions(0, +), [0])
|
||||
|
||||
XCTAssertEqual([1, 2, 3, 4].lazy.reductions(into: 0, +=), [0, 1, 3, 6, 10])
|
||||
XCTAssertEqual(
|
||||
[1, 2, 3, 4].lazy.reductions(into: 0, +=), [0, 1, 3, 6, 10])
|
||||
|
||||
XCTAssertEqual([1].lazy.reductions(into: 0, +=), [0, 1])
|
||||
|
||||
XCTAssertEqual(EmptyCollection<Int>().lazy.reductions(into: 0, +=), [0])
|
||||
|
||||
XCTAssertLazySequence((1...).prefix(1).lazy.reductions(0, +))
|
||||
XCTAssertLazySequence([1].lazy.reductions(0, +))
|
||||
XCTAssertLazyCollection([1].lazy.reductions(0, +))
|
||||
requireLazySequence((1...).prefix(1).lazy.reductions(0, +))
|
||||
requireLazySequence([1].lazy.reductions(0, +))
|
||||
requireLazyCollection([1].lazy.reductions(0, +))
|
||||
}
|
||||
|
||||
func testExclusiveEager() {
|
||||
@@ -51,9 +54,11 @@ final class ReductionsTests: XCTestCase {
|
||||
XCTAssertNoThrow(try [].reductions(0) { _, _ in throw TestError() })
|
||||
XCTAssertThrowsError(try [1].reductions(0) { _, _ in throw TestError() })
|
||||
}
|
||||
|
||||
|
||||
func testExclusiveIndexTraversals() {
|
||||
let validator = IndexValidator<ExclusiveReductionsSequence<Range<Int>, Int>>()
|
||||
let validator = IndexValidator<
|
||||
ExclusiveReductionsSequence<Range<Int>, Int>
|
||||
>()
|
||||
validator.validate((0..<0).lazy.reductions(0, +), expectedCount: 1)
|
||||
validator.validate((0..<1).lazy.reductions(0, +), expectedCount: 2)
|
||||
validator.validate((0..<4).lazy.reductions(0, +), expectedCount: 5)
|
||||
@@ -62,17 +67,17 @@ final class ReductionsTests: XCTestCase {
|
||||
// MARK: - Inclusive Reductions
|
||||
|
||||
func testInclusiveLazy() {
|
||||
XCTAssertEqualSequences((1...).prefix(4).lazy.reductions(+), [1, 3, 6, 10])
|
||||
XCTAssertEqualSequences((1...).prefix(1).lazy.reductions(+), [1])
|
||||
XCTAssertEqualSequences((1...).prefix(0).lazy.reductions(+), [])
|
||||
expectEqualSequences((1...).prefix(4).lazy.reductions(+), [1, 3, 6, 10])
|
||||
expectEqualSequences((1...).prefix(1).lazy.reductions(+), [1])
|
||||
expectEqualSequences((1...).prefix(0).lazy.reductions(+), [])
|
||||
|
||||
XCTAssertEqualCollections([1, 2, 3, 4].lazy.reductions(+), [1, 3, 6, 10])
|
||||
XCTAssertEqualCollections([1].lazy.reductions(+), [1])
|
||||
XCTAssertEqualCollections(EmptyCollection<Int>().lazy.reductions(+), [])
|
||||
expectEqualCollections([1, 2, 3, 4].lazy.reductions(+), [1, 3, 6, 10])
|
||||
expectEqualCollections([1].lazy.reductions(+), [1])
|
||||
expectEqualCollections(EmptyCollection<Int>().lazy.reductions(+), [])
|
||||
|
||||
XCTAssertLazySequence((1...).prefix(1).lazy.reductions(+))
|
||||
XCTAssertLazySequence([1].lazy.reductions(+))
|
||||
XCTAssertLazyCollection([1].lazy.reductions(+))
|
||||
requireLazySequence((1...).prefix(1).lazy.reductions(+))
|
||||
requireLazySequence([1].lazy.reductions(+))
|
||||
requireLazyCollection([1].lazy.reductions(+))
|
||||
}
|
||||
|
||||
func testInclusiveEager() {
|
||||
@@ -84,7 +89,7 @@ final class ReductionsTests: XCTestCase {
|
||||
XCTAssertNoThrow(try [1].reductions { _, _ in throw TestError() })
|
||||
XCTAssertThrowsError(try [1, 1].reductions { _, _ in throw TestError() })
|
||||
}
|
||||
|
||||
|
||||
func testInclusiveIndexTraversals() {
|
||||
let validator = IndexValidator<InclusiveReductionsSequence<Range<Int>>>()
|
||||
validator.validate((0..<0).lazy.reductions(+), expectedCount: 0)
|
||||
|
||||
@@ -10,77 +10,87 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
|
||||
@testable import Algorithms
|
||||
|
||||
final class RotateTests: XCTestCase {
|
||||
/// Tests the example given in `_reverse(subrange:until:)`’s documentation
|
||||
/// Tests the example given in the `_reverse(subrange:until:)` documentation.
|
||||
func testUnderscoreReverse() {
|
||||
var input = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p"]
|
||||
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 expected = ["p", "o", "n", "m", "e", "f", "g", "h", "i", "j", "k", "l", "d", "c", "b", "a"]
|
||||
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
|
||||
|
||||
/// Tests the example given in the `reverse(subrange:)` 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
|
||||
|
||||
/// Tests `rotate(subrange:toStartAt:)` with an empty subrange.
|
||||
func testRotateEmptySubrange() {
|
||||
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
let oldStart = numbers.rotate(subrange: 3..<3, toStartAt: 3)
|
||||
// The order of elements are unchanged
|
||||
XCTAssertEqual(numbers, [10, 20, 30, 40, 50, 60, 70, 80])
|
||||
XCTAssertEqual(numbers[oldStart], 40)
|
||||
}
|
||||
|
||||
/// Tests `rotate(subrange:toStartAt:)` with an empty collection
|
||||
|
||||
/// Tests `rotate(subrange:toStartAt:)` with an empty collection.
|
||||
func testRotateSubrangeOnEmptyCollection() {
|
||||
var numbers = [Int]()
|
||||
var numbers: [Int] = []
|
||||
let oldStart = numbers.rotate(subrange: 0..<0, toStartAt: 0)
|
||||
XCTAssertEqual(numbers, [])
|
||||
XCTAssertEqual(oldStart, numbers.startIndex)
|
||||
}
|
||||
|
||||
/// Tests `rotate(subrange:toStartAt:)` with the full range of the collection
|
||||
|
||||
/// Tests `rotate(subrange:toStartAt:)` with the full range of the collection.
|
||||
func testRotateFullRange() {
|
||||
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
let oldStart = numbers.rotate(subrange: 0..<8, toStartAt: 1)
|
||||
XCTAssertEqual(numbers, [20, 30, 40, 50, 60, 70, 80, 10])
|
||||
XCTAssertEqual(numbers[oldStart], 10)
|
||||
}
|
||||
|
||||
/// Tests the example given in `rotate(subrange:toStartAt:)`’s documentation
|
||||
|
||||
/// Tests the example given in the `rotate(subrange:toStartAt:)`
|
||||
/// documentation.
|
||||
func testRotateSubrange() {
|
||||
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
let oldStart = numbers.rotate(subrange: 0..<4, toStartAt: 2)
|
||||
XCTAssertEqual(numbers, [30, 40, 10, 20, 50, 60, 70, 80])
|
||||
XCTAssertEqual(numbers[oldStart], 10)
|
||||
}
|
||||
|
||||
/// Tests the example given in `rotate(toStartAt:)`’s documentation
|
||||
|
||||
/// Tests the example given in the `rotate(toStartAt:)` documentation.
|
||||
func testRotateExample() {
|
||||
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
let oldStart = numbers.rotate(toStartAt: 3)
|
||||
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
|
||||
|
||||
/// Tests `rotate(toStartAt:)` on collections of varying lengths, at
|
||||
/// different starting points.
|
||||
func testRotate() {
|
||||
for length in 0...15 {
|
||||
let a = Array(0..<length)
|
||||
var b = a
|
||||
for j in 0..<length {
|
||||
let i = b.rotate(toStartAt: j)
|
||||
XCTAssertEqualSequences(a[j...] + a[..<j], b)
|
||||
expectEqualSequences(a[j...] + a[..<j], b)
|
||||
b.rotate(toStartAt: i)
|
||||
XCTAssertEqual(a, b)
|
||||
}
|
||||
|
||||
@@ -112,7 +112,7 @@ final class SplitTests: 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 {
|
||||
@@ -480,11 +480,11 @@ final class SplitTests: XCTestCase {
|
||||
|
||||
func testLaziness() {
|
||||
let splitSequence = AnySequence([1, 2, 42, 3]).lazy.split(separator: 42)
|
||||
XCTAssertLazySequence(splitSequence)
|
||||
requireLazySequence(splitSequence)
|
||||
|
||||
let splitCollection = "foo.bar".lazy.split(separator: ".")
|
||||
XCTAssertLazySequence(splitCollection)
|
||||
XCTAssertLazyCollection(splitCollection)
|
||||
requireLazySequence(splitCollection)
|
||||
requireLazyCollection(splitCollection)
|
||||
}
|
||||
|
||||
// TODO: Need a version of `validateIndexTraversals` that doesn't require
|
||||
@@ -564,20 +564,20 @@ final class SplitTests: XCTestCase {
|
||||
where T.Element == C.Element {
|
||||
// Default max splits, omitting empty sequences
|
||||
switch separator {
|
||||
case let .element(element):
|
||||
case .element(let element):
|
||||
let expected = s.split(separator: element).map { Array($0) }
|
||||
let actual = s.lazy.split(separator: element)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .defaultValue,
|
||||
omittingEmptySubsequences: .defaultValue)
|
||||
)
|
||||
case let .closure(closure):
|
||||
case .closure(let closure):
|
||||
let expected = s.split(whereSeparator: closure).map { Array($0) }
|
||||
let actual = s.lazy.split(whereSeparator: closure)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
@@ -588,7 +588,7 @@ final class SplitTests: XCTestCase {
|
||||
|
||||
// Provided max splits, omitting empty sequences
|
||||
switch separator {
|
||||
case let .element(element):
|
||||
case .element(let element):
|
||||
let expected = s.split(
|
||||
separator: element,
|
||||
maxSplits: maxSplits
|
||||
@@ -597,14 +597,14 @@ final class SplitTests: XCTestCase {
|
||||
separator: element,
|
||||
maxSplits: maxSplits
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .provided(maxSplits),
|
||||
omittingEmptySubsequences: .defaultValue)
|
||||
)
|
||||
case let .closure(closure):
|
||||
case .closure(let closure):
|
||||
let expected = s.split(
|
||||
maxSplits: maxSplits,
|
||||
whereSeparator: closure
|
||||
@@ -613,7 +613,7 @@ final class SplitTests: XCTestCase {
|
||||
maxSplits: maxSplits,
|
||||
whereSeparator: closure
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
@@ -624,7 +624,7 @@ final class SplitTests: XCTestCase {
|
||||
|
||||
// Default max splits, including empty sequences
|
||||
switch separator {
|
||||
case let .element(element):
|
||||
case .element(let element):
|
||||
let expected = s.split(
|
||||
separator: element,
|
||||
omittingEmptySubsequences: false
|
||||
@@ -633,14 +633,14 @@ final class SplitTests: XCTestCase {
|
||||
separator: element,
|
||||
omittingEmptySubsequences: false
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .defaultValue,
|
||||
omittingEmptySubsequences: .provided(false))
|
||||
)
|
||||
case let .closure(closure):
|
||||
case .closure(let closure):
|
||||
let expected = s.split(
|
||||
omittingEmptySubsequences: false,
|
||||
whereSeparator: closure
|
||||
@@ -649,7 +649,7 @@ final class SplitTests: XCTestCase {
|
||||
omittingEmptySubsequences: false,
|
||||
whereSeparator: closure
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
@@ -660,7 +660,7 @@ final class SplitTests: XCTestCase {
|
||||
|
||||
// Provided max splits, including empty sequences
|
||||
switch separator {
|
||||
case let .element(element):
|
||||
case .element(let element):
|
||||
let expected = s.split(
|
||||
separator: element,
|
||||
maxSplits: maxSplits,
|
||||
@@ -671,14 +671,14 @@ final class SplitTests: XCTestCase {
|
||||
maxSplits: maxSplits,
|
||||
omittingEmptySubsequences: false
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .provided(maxSplits),
|
||||
omittingEmptySubsequences: .provided(false))
|
||||
)
|
||||
case let .closure(closure):
|
||||
case .closure(let closure):
|
||||
let expected = s.split(
|
||||
maxSplits: maxSplits,
|
||||
omittingEmptySubsequences: false,
|
||||
@@ -689,7 +689,7 @@ final class SplitTests: XCTestCase {
|
||||
omittingEmptySubsequences: false,
|
||||
whereSeparator: closure
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
@@ -702,20 +702,20 @@ final class SplitTests: XCTestCase {
|
||||
private func _validateAsCollection(_ c: C) {
|
||||
// Default max splits, omitting empty sequences
|
||||
switch separator {
|
||||
case let .element(element):
|
||||
case .element(let element):
|
||||
let expected = c.split(separator: element)
|
||||
let actual = c.lazy.split(separator: element)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .defaultValue,
|
||||
omittingEmptySubsequences: .defaultValue)
|
||||
)
|
||||
case let .closure(closure):
|
||||
case .closure(let closure):
|
||||
let expected = c.split(whereSeparator: closure)
|
||||
let actual = c.lazy.split(whereSeparator: closure)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
@@ -726,7 +726,7 @@ final class SplitTests: XCTestCase {
|
||||
|
||||
// Provided max splits, omitting empty sequences
|
||||
switch separator {
|
||||
case let .element(element):
|
||||
case .element(let element):
|
||||
let expected = c.split(
|
||||
separator: element,
|
||||
maxSplits: maxSplits
|
||||
@@ -735,14 +735,14 @@ final class SplitTests: XCTestCase {
|
||||
separator: element,
|
||||
maxSplits: maxSplits
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .provided(maxSplits),
|
||||
omittingEmptySubsequences: .defaultValue)
|
||||
)
|
||||
case let .closure(closure):
|
||||
case .closure(let closure):
|
||||
let expected = c.split(
|
||||
maxSplits: maxSplits,
|
||||
whereSeparator: closure
|
||||
@@ -751,7 +751,7 @@ final class SplitTests: XCTestCase {
|
||||
maxSplits: maxSplits,
|
||||
whereSeparator: closure
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
@@ -762,7 +762,7 @@ final class SplitTests: XCTestCase {
|
||||
|
||||
// Default max splits, including empty sequences
|
||||
switch separator {
|
||||
case let .element(element):
|
||||
case .element(let element):
|
||||
let expected = c.split(
|
||||
separator: element,
|
||||
omittingEmptySubsequences: false
|
||||
@@ -771,14 +771,14 @@ final class SplitTests: XCTestCase {
|
||||
separator: element,
|
||||
omittingEmptySubsequences: false
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .defaultValue,
|
||||
omittingEmptySubsequences: .provided(false))
|
||||
)
|
||||
case let .closure(closure):
|
||||
case .closure(let closure):
|
||||
let expected = c.split(
|
||||
omittingEmptySubsequences: false,
|
||||
whereSeparator: closure
|
||||
@@ -787,7 +787,7 @@ final class SplitTests: XCTestCase {
|
||||
omittingEmptySubsequences: false,
|
||||
whereSeparator: closure
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
@@ -798,7 +798,7 @@ final class SplitTests: XCTestCase {
|
||||
|
||||
// Provided max splits, including empty sequences
|
||||
switch separator {
|
||||
case let .element(element):
|
||||
case .element(let element):
|
||||
let expected = c.split(
|
||||
separator: element,
|
||||
maxSplits: maxSplits,
|
||||
@@ -809,14 +809,14 @@ final class SplitTests: XCTestCase {
|
||||
maxSplits: maxSplits,
|
||||
omittingEmptySubsequences: false
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .provided(maxSplits),
|
||||
omittingEmptySubsequences: .provided(false))
|
||||
)
|
||||
case let .closure(closure):
|
||||
case .closure(let closure):
|
||||
let expected = c.split(
|
||||
maxSplits: maxSplits,
|
||||
omittingEmptySubsequences: false,
|
||||
@@ -827,7 +827,7 @@ final class SplitTests: XCTestCase {
|
||||
omittingEmptySubsequences: false,
|
||||
whereSeparator: closure
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
|
||||
@@ -9,45 +9,45 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class StridingTests: XCTestCase {
|
||||
|
||||
|
||||
func testStride() {
|
||||
let a = 0...10
|
||||
XCTAssertEqualSequences(a.striding(by: 1), (0...10))
|
||||
XCTAssertEqualSequences(a.striding(by: 2), [0, 2, 4, 6, 8, 10])
|
||||
XCTAssertEqualSequences(a.striding(by: 3), [0, 3, 6, 9])
|
||||
XCTAssertEqualSequences(a.striding(by: 4), [0, 4, 8])
|
||||
XCTAssertEqualSequences(a.striding(by: 5), [0, 5, 10])
|
||||
XCTAssertEqualSequences(a.striding(by: 10), [0, 10])
|
||||
XCTAssertEqualSequences(a.striding(by: 11), [0])
|
||||
|
||||
expectEqualSequences(a.striding(by: 1), (0...10))
|
||||
expectEqualSequences(a.striding(by: 2), [0, 2, 4, 6, 8, 10])
|
||||
expectEqualSequences(a.striding(by: 3), [0, 3, 6, 9])
|
||||
expectEqualSequences(a.striding(by: 4), [0, 4, 8])
|
||||
expectEqualSequences(a.striding(by: 5), [0, 5, 10])
|
||||
expectEqualSequences(a.striding(by: 10), [0, 10])
|
||||
expectEqualSequences(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])
|
||||
XCTAssertEqualSequences(s.striding(by: 3), [0, 3, 6, 9])
|
||||
XCTAssertEqualSequences(s.striding(by: 4), [0, 4, 8])
|
||||
XCTAssertEqualSequences(s.striding(by: 5), [0, 5, 10])
|
||||
XCTAssertEqualSequences(s.striding(by: 10), [0, 10])
|
||||
XCTAssertEqualSequences(s.striding(by: 11), [0])
|
||||
|
||||
expectEqualSequences(s.striding(by: 1), (0...10))
|
||||
expectEqualSequences(s.striding(by: 2), [0, 2, 4, 6, 8, 10])
|
||||
expectEqualSequences(s.striding(by: 3), [0, 3, 6, 9])
|
||||
expectEqualSequences(s.striding(by: 4), [0, 4, 8])
|
||||
expectEqualSequences(s.striding(by: 5), [0, 5, 10])
|
||||
expectEqualSequences(s.striding(by: 10), [0, 10])
|
||||
expectEqualSequences(s.striding(by: 11), [0])
|
||||
|
||||
let empty = (0...).prefix(0)
|
||||
XCTAssertEqualSequences(empty.striding(by: 2), [])
|
||||
expectEqualSequences(empty.striding(by: 2), [])
|
||||
}
|
||||
|
||||
|
||||
func testStrideString() {
|
||||
let s = "swift"
|
||||
XCTAssertEqualSequences(s.striding(by: 2), ["s", "i", "t"])
|
||||
expectEqualSequences(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])
|
||||
expectEqualSequences(a.striding(by: 3).reversed(), [3, 0])
|
||||
expectEqualSequences(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,15 +86,15 @@ final class StridingTests: XCTestCase {
|
||||
XCTAssertEqual(a.striding(by: 10).count, [0, 10].count)
|
||||
XCTAssertEqual(a.striding(by: 11).count, [0].count)
|
||||
}
|
||||
|
||||
|
||||
func testIndexTraversals() {
|
||||
do {
|
||||
let empty = [Int]()
|
||||
let empty: [Int] = []
|
||||
let validator = IndexValidator<StridingCollection<[Int]>>()
|
||||
validator.validate(empty.striding(by: 1))
|
||||
validator.validate(empty.striding(by: 2))
|
||||
}
|
||||
|
||||
|
||||
do {
|
||||
let range = 0...100
|
||||
let validator = IndexValidator<StridingCollection<ClosedRange<Int>>>()
|
||||
@@ -102,7 +102,7 @@ final class StridingTests: XCTestCase {
|
||||
validator.validate(range.striding(by: 11))
|
||||
validator.validate(range.striding(by: 101))
|
||||
}
|
||||
|
||||
|
||||
do {
|
||||
let array = Array(0...100)
|
||||
let validator = IndexValidator<StridingCollection<[Int]>>()
|
||||
@@ -110,7 +110,7 @@ final class StridingTests: XCTestCase {
|
||||
validator.validate(array.striding(by: 11))
|
||||
validator.validate(array.striding(by: 101))
|
||||
}
|
||||
|
||||
|
||||
do {
|
||||
let string = "swift rocks"
|
||||
let validator = IndexValidator<StridingCollection<String>>()
|
||||
@@ -119,7 +119,7 @@ final class StridingTests: XCTestCase {
|
||||
validator.validate(string.striding(by: 10))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testOffsetBy() {
|
||||
let a = (0...100).striding(by: 22)
|
||||
let b = [0, 22, 44, 66, 88]
|
||||
@@ -127,17 +127,17 @@ 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)
|
||||
}
|
||||
|
||||
|
||||
func testLazy() {
|
||||
XCTAssertLazySequence(AnySequence(0..<100).lazy.striding(by: 3))
|
||||
XCTAssertLazySequence((0..<100).lazy.striding(by: 3))
|
||||
XCTAssertLazyCollection((0..<100).lazy.striding(by: 3))
|
||||
requireLazySequence(AnySequence(0..<100).lazy.striding(by: 3))
|
||||
requireLazySequence((0..<100).lazy.striding(by: 3))
|
||||
requireLazyCollection((0..<100).lazy.striding(by: 3))
|
||||
}
|
||||
}
|
||||
@@ -9,40 +9,40 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class SuffixTests: XCTestCase {
|
||||
func testSuffix() {
|
||||
let a = 0...10
|
||||
XCTAssertEqualSequences(a.suffix(while: { $0 > 5 }), (6...10))
|
||||
XCTAssertEqualSequences(a.suffix(while: { $0 > 10 }), [])
|
||||
XCTAssertEqualSequences(a.suffix(while: { $0 > 9 }), [10])
|
||||
XCTAssertEqualSequences(a.suffix(while: { $0 > -1 }), (0...10))
|
||||
|
||||
expectEqualSequences(a.suffix(while: { $0 > 5 }), (6...10))
|
||||
expectEqualSequences(a.suffix(while: { $0 > 10 }), [])
|
||||
expectEqualSequences(a.suffix(while: { $0 > 9 }), [10])
|
||||
expectEqualSequences(a.suffix(while: { $0 > -1 }), (0...10))
|
||||
|
||||
let empty: [Int] = []
|
||||
XCTAssertEqualSequences(empty.suffix(while: { $0 > 10 }), [])
|
||||
expectEqualSequences(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]()
|
||||
|
||||
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]()
|
||||
|
||||
let empty: [Int] = []
|
||||
XCTAssertEqual(empty.startOfSuffix(while: { $0 < 3 }), 0)
|
||||
XCTAssertEqual(empty.startOfSuffix(while: { _ in false }), empty.endIndex)
|
||||
XCTAssertEqual(empty.startOfSuffix(while: { _ in true }), empty.startIndex)
|
||||
|
||||
@@ -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 }
|
||||
|
||||
@@ -74,21 +74,22 @@ extension MutableCollection {
|
||||
}
|
||||
}
|
||||
|
||||
func XCTAssertEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
func expectEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
_ expression1: @autoclosure () throws -> S1,
|
||||
_ expression2: @autoclosure () throws -> S2,
|
||||
_ message: @autoclosure () -> String = "",
|
||||
file: StaticString = #file, line: UInt = #line
|
||||
file: StaticString = (#file), line: UInt = #line
|
||||
) rethrows where S1.Element: Equatable, S1.Element == S2.Element {
|
||||
try XCTAssertEqualSequences(expression1(), expression2(), by: ==,
|
||||
try expectEqualSequences(
|
||||
expression1(), expression2(), by: ==,
|
||||
message(), file: file, line: line)
|
||||
}
|
||||
|
||||
// Two sequences contains exactly the same element but not necessarily in the same order.
|
||||
func XCTAssertUnorderedEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
func expectUnorderedEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
_ expression1: @autoclosure () throws -> S1,
|
||||
_ expression2: @autoclosure () throws -> S2,
|
||||
file: StaticString = #file, line: UInt = #line
|
||||
file: StaticString = (#file), line: UInt = #line
|
||||
) rethrows where S1.Element: Equatable, S1.Element == S2.Element {
|
||||
var s1 = Array(try expression1())
|
||||
var missing: [S1.Element] = []
|
||||
@@ -99,9 +100,10 @@ func XCTAssertUnorderedEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
}
|
||||
s1.remove(at: idx)
|
||||
}
|
||||
|
||||
|
||||
XCTAssertTrue(
|
||||
missing.isEmpty, "first sequence missing '\(missing)' elements from second sequence",
|
||||
missing.isEmpty,
|
||||
"first sequence missing '\(missing)' elements from second sequence",
|
||||
file: file, line: line
|
||||
)
|
||||
|
||||
@@ -111,18 +113,19 @@ func XCTAssertUnorderedEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
)
|
||||
}
|
||||
|
||||
func XCTAssertEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
func expectEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
_ expression1: @autoclosure () throws -> S1,
|
||||
_ expression2: @autoclosure () throws -> S2,
|
||||
by areEquivalent: (S1.Element, S1.Element) -> Bool,
|
||||
_ message: @autoclosure () -> String = "",
|
||||
file: StaticString = #file, line: UInt = #line
|
||||
file: StaticString = (#file), line: UInt = #line
|
||||
) rethrows where S1.Element == S2.Element {
|
||||
|
||||
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()
|
||||
@@ -130,11 +133,13 @@ func XCTAssertEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
var idx = 0
|
||||
while true {
|
||||
switch (iter1.next(), iter2.next()) {
|
||||
case let (e1?, e2?) where areEquivalent(e1, e2):
|
||||
case (let e1?, let e2?) where areEquivalent(e1, e2):
|
||||
idx += 1
|
||||
continue
|
||||
case let (e1?, e2?):
|
||||
fail("element \(e1) on first sequence does not match element \(e2) on second sequence at position \(idx)")
|
||||
case (let e1?, let e2?):
|
||||
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, _?):
|
||||
@@ -145,19 +150,20 @@ func XCTAssertEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
}
|
||||
}
|
||||
|
||||
func XCTAssertLazySequence<S: LazySequenceProtocol>(_: S) {}
|
||||
func XCTAssertLazyCollection<S: LazyCollectionProtocol>(_: S) {}
|
||||
func requireLazySequence<S: LazySequenceProtocol>(_: S) {}
|
||||
func requireLazyCollection<S: LazyCollectionProtocol>(_: S) {}
|
||||
|
||||
/// Asserts two collections are equal by using their indices to access elements.
|
||||
func XCTAssertEqualCollections<C1: Collection, C2: Collection>(
|
||||
func expectEqualCollections<C1: Collection, C2: Collection>(
|
||||
_ expression1: @autoclosure () throws -> C1,
|
||||
_ expression2: @autoclosure () throws -> C2,
|
||||
_ message: @autoclosure () -> String = "",
|
||||
file: StaticString = #file, line: UInt = #line
|
||||
file: StaticString = (#file), line: UInt = #line
|
||||
) rethrows where C1.Element: Equatable, C1.Element == C2.Element {
|
||||
let c1 = try expression1()
|
||||
let c2 = try expression2()
|
||||
XCTAssertEqual(c1.indices.count, c2.indices.count, message(), file: file, line: line)
|
||||
XCTAssertEqual(
|
||||
c1.indices.count, c2.indices.count, message(), file: file, line: line)
|
||||
for index in zip(c1.indices, c2.indices) {
|
||||
XCTAssertEqual(c1[index.0], c2[index.1], message(), file: file, line: line)
|
||||
}
|
||||
@@ -166,7 +172,7 @@ func XCTAssertEqualCollections<C1: Collection, C2: Collection>(
|
||||
struct IndexValidator<C: Collection> {
|
||||
let testRandomAccess = true
|
||||
let indicesIncludingEnd: (C) -> [C.Index]
|
||||
|
||||
|
||||
/// Creates a new instance of an index validator that can verify that indices
|
||||
/// of a collection behave correctly and consistently.
|
||||
///
|
||||
@@ -188,7 +194,9 @@ struct IndexValidator<C: Collection> {
|
||||
/// using the contents of the collection directly.
|
||||
init(
|
||||
testRandomAccess: Bool = true,
|
||||
indicesIncludingEnd: @escaping (C) -> [C.Index] = { $0.indices + [$0.endIndex] }
|
||||
indicesIncludingEnd: @escaping (C) -> [C.Index] = {
|
||||
$0.indices + [$0.endIndex]
|
||||
}
|
||||
) {
|
||||
self.indicesIncludingEnd = indicesIncludingEnd
|
||||
}
|
||||
@@ -202,7 +210,7 @@ extension IndexValidator {
|
||||
let file: StaticString
|
||||
let line: UInt
|
||||
}
|
||||
|
||||
|
||||
/// Verifies that all index traversal methods behave as expected.
|
||||
///
|
||||
/// Verifies the correctness of the implementations of `startIndex`,
|
||||
@@ -211,10 +219,6 @@ extension IndexValidator {
|
||||
/// `distance(from:to:)` by calling them with just about all possible input
|
||||
/// combinations.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - collection: The collection to be validated.
|
||||
/// - expectedCount:
|
||||
///
|
||||
/// - Complexity: O(*n*^3) where *n* is the length of the collection if the
|
||||
/// collection conforms to `RandomAccessCollection`, otherwise O(*n*^4).
|
||||
func validate(
|
||||
@@ -224,13 +228,13 @@ extension IndexValidator {
|
||||
) {
|
||||
let indicesIncludingEnd = self.indicesIncludingEnd(collection)
|
||||
let count = indicesIncludingEnd.count - 1
|
||||
|
||||
|
||||
let validator = Validator(
|
||||
collection: collection,
|
||||
count: count,
|
||||
indicesIncludingEnd: indicesIncludingEnd,
|
||||
file: file, line: line)
|
||||
|
||||
|
||||
validator.validateForward(
|
||||
testRandomAccess: testRandomAccess,
|
||||
expectedCount: expectedCount)
|
||||
@@ -244,13 +248,13 @@ extension IndexValidator where C: BidirectionalCollection {
|
||||
) {
|
||||
let indicesIncludingEnd = self.indicesIncludingEnd(collection)
|
||||
let count = indicesIncludingEnd.count - 1
|
||||
|
||||
|
||||
let validator = Validator(
|
||||
collection: collection,
|
||||
count: count,
|
||||
indicesIncludingEnd: indicesIncludingEnd,
|
||||
file: file, line: line)
|
||||
|
||||
|
||||
validator.validateForward(
|
||||
testRandomAccess: testRandomAccess,
|
||||
expectedCount: expectedCount)
|
||||
@@ -264,7 +268,7 @@ extension IndexValidator.Validator {
|
||||
XCTAssertEqual(
|
||||
expectedCount, count, "Count mismatch", file: file, line: line)
|
||||
}
|
||||
|
||||
|
||||
XCTAssertEqual(
|
||||
collection.count, count,
|
||||
"Count mismatch",
|
||||
@@ -281,21 +285,21 @@ extension IndexValidator.Validator {
|
||||
collection.endIndex, indicesIncludingEnd.last,
|
||||
"`endIndex` does not equal the last index",
|
||||
file: file, line: line)
|
||||
|
||||
|
||||
validateIndexAfter()
|
||||
validateIndices()
|
||||
validateIndexComparisons()
|
||||
|
||||
|
||||
if testRandomAccess {
|
||||
validateDistanceFromTo()
|
||||
validateIndexOffsetBy()
|
||||
validateIndexOffsetByLimitedBy()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func validateIndexAfter() {
|
||||
var index = collection.startIndex
|
||||
|
||||
|
||||
for (offset, expected) in indicesIncludingEnd.enumerated().dropFirst() {
|
||||
collection.formIndex(after: &index)
|
||||
XCTAssertEqual(
|
||||
@@ -307,7 +311,7 @@ extension IndexValidator.Validator {
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func validateIndices() {
|
||||
XCTAssertEqual(collection.indices.count, count)
|
||||
for (offset, index) in collection.indices.enumerated() {
|
||||
@@ -317,7 +321,7 @@ extension IndexValidator.Validator {
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func validateIndexComparisons() {
|
||||
for (offsetA, a) in indicesIncludingEnd.enumerated() {
|
||||
XCTAssertEqual(
|
||||
@@ -328,7 +332,7 @@ extension IndexValidator.Validator {
|
||||
a < a,
|
||||
"Index at offset \(offsetA) is less than itself",
|
||||
file: file, line: line)
|
||||
|
||||
|
||||
for (offsetB, b) in indicesIncludingEnd[..<offsetA].enumerated() {
|
||||
XCTAssertNotEqual(
|
||||
a, b,
|
||||
@@ -343,10 +347,12 @@ extension IndexValidator.Validator {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func validateDistanceFromTo() {
|
||||
for (startOffset, start) in indicesIncludingEnd.enumerated() {
|
||||
for (endOffset, end) in indicesIncludingEnd.enumerated().dropFirst(startOffset) {
|
||||
for (endOffset, end) in indicesIncludingEnd.enumerated().dropFirst(
|
||||
startOffset)
|
||||
{
|
||||
let distance = endOffset - startOffset
|
||||
XCTAssertEqual(
|
||||
collection.distance(from: start, to: end), distance,
|
||||
@@ -358,10 +364,12 @@ extension IndexValidator.Validator {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func validateIndexOffsetBy() {
|
||||
for (startOffset, start) in indicesIncludingEnd.enumerated() {
|
||||
for (endOffset, end) in indicesIncludingEnd.enumerated().dropFirst(startOffset) {
|
||||
for (endOffset, end) in indicesIncludingEnd.enumerated().dropFirst(
|
||||
startOffset)
|
||||
{
|
||||
let distance = endOffset - startOffset
|
||||
XCTAssertEqual(
|
||||
collection.index(start, offsetBy: distance), end,
|
||||
@@ -373,7 +381,7 @@ extension IndexValidator.Validator {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func validateIndexOffsetByLimitedBy() {
|
||||
for (startOffset, start) in indicesIncludingEnd.enumerated() {
|
||||
for (limitOffset, limit) in indicesIncludingEnd.enumerated() {
|
||||
@@ -384,8 +392,9 @@ extension IndexValidator.Validator {
|
||||
func checkTargetRange(_ range: ClosedRange<Int>, pastLimit: Bool) {
|
||||
for targetOffset in range {
|
||||
let distance = targetOffset - startOffset
|
||||
let end = collection.index(start, offsetBy: distance, limitedBy: limit)
|
||||
|
||||
let end = collection.index(
|
||||
start, offsetBy: distance, limitedBy: limit)
|
||||
|
||||
if pastLimit {
|
||||
XCTAssertNil(
|
||||
end,
|
||||
@@ -406,7 +415,7 @@ extension IndexValidator.Validator {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if limit >= start {
|
||||
// the limit has an effect
|
||||
checkTargetRange(startOffset...limitOffset, pastLimit: false)
|
||||
@@ -423,18 +432,20 @@ extension IndexValidator.Validator {
|
||||
extension IndexValidator.Validator where C: BidirectionalCollection {
|
||||
func validateBackward(testRandomAccess: Bool) {
|
||||
validateIndexBefore()
|
||||
|
||||
|
||||
if testRandomAccess {
|
||||
validateDistanceFromTo()
|
||||
validateIndexOffsetBy()
|
||||
validateIndexOffsetByLimitedBy()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func validateIndexBefore() {
|
||||
var index = collection.endIndex
|
||||
|
||||
for (offset, expected) in indicesIncludingEnd.enumerated().dropLast().reversed() {
|
||||
for (offset, expected) in indicesIncludingEnd.enumerated().dropLast()
|
||||
.reversed()
|
||||
{
|
||||
collection.formIndex(before: &index)
|
||||
XCTAssertEqual(
|
||||
index, expected,
|
||||
@@ -445,10 +456,12 @@ extension IndexValidator.Validator where C: BidirectionalCollection {
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func validateDistanceFromTo() {
|
||||
for (startOffset, start) in indicesIncludingEnd.enumerated() {
|
||||
for (endOffset, end) in indicesIncludingEnd.enumerated().prefix(startOffset) {
|
||||
for (endOffset, end) in indicesIncludingEnd.enumerated().prefix(
|
||||
startOffset)
|
||||
{
|
||||
let distance = endOffset - startOffset
|
||||
XCTAssertEqual(
|
||||
collection.distance(from: start, to: end), distance,
|
||||
@@ -460,10 +473,12 @@ extension IndexValidator.Validator where C: BidirectionalCollection {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func validateIndexOffsetBy() {
|
||||
for (startOffset, start) in indicesIncludingEnd.enumerated() {
|
||||
for (endOffset, end) in indicesIncludingEnd.enumerated().prefix(startOffset) {
|
||||
for (endOffset, end) in indicesIncludingEnd.enumerated().prefix(
|
||||
startOffset)
|
||||
{
|
||||
let distance = endOffset - startOffset
|
||||
XCTAssertEqual(
|
||||
collection.index(start, offsetBy: distance), end,
|
||||
@@ -475,7 +490,7 @@ extension IndexValidator.Validator where C: BidirectionalCollection {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func validateIndexOffsetByLimitedBy() {
|
||||
for (startOffset, start) in indicesIncludingEnd.enumerated() {
|
||||
for (limitOffset, limit) in indicesIncludingEnd.enumerated() {
|
||||
@@ -486,8 +501,9 @@ extension IndexValidator.Validator where C: BidirectionalCollection {
|
||||
func checkTargetRange(_ range: ClosedRange<Int>, pastLimit: Bool) {
|
||||
for targetOffset in range {
|
||||
let distance = targetOffset - startOffset
|
||||
let end = collection.index(start, offsetBy: distance, limitedBy: limit)
|
||||
|
||||
let end = collection.index(
|
||||
start, offsetBy: distance, limitedBy: limit)
|
||||
|
||||
if pastLimit {
|
||||
XCTAssertNil(
|
||||
end,
|
||||
@@ -508,7 +524,7 @@ extension IndexValidator.Validator where C: BidirectionalCollection {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if limit <= start {
|
||||
// the limit has an effect
|
||||
checkTargetRange(limitOffset...startOffset, pastLimit: false)
|
||||
|
||||
@@ -13,74 +13,78 @@ import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class TrimTests: XCTestCase {
|
||||
|
||||
|
||||
func testEmpty() {
|
||||
let results_empty = ([] as [Int]).trimming { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(results_empty, [])
|
||||
let resultsEmpty = ([] as [Int]).trimming { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(resultsEmpty, [])
|
||||
}
|
||||
|
||||
|
||||
func testNoMatch() {
|
||||
// No match (nothing trimmed).
|
||||
let results_nomatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming {
|
||||
let resultsNoMatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming {
|
||||
$0.isMultiple(of: 2)
|
||||
}
|
||||
XCTAssertEqual(results_nomatch, [1, 3, 5, 7, 9, 11, 13, 15])
|
||||
XCTAssertEqual(resultsNoMatch, [1, 3, 5, 7, 9, 11, 13, 15])
|
||||
}
|
||||
|
||||
|
||||
func testNoTailMatch() {
|
||||
// No tail match (only trim head).
|
||||
let results_notailmatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { $0 < 10 }
|
||||
XCTAssertEqual(results_notailmatch, [11, 13, 15])
|
||||
let resultsNoTailMatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { $0 < 10 }
|
||||
XCTAssertEqual(resultsNoTailMatch, [11, 13, 15])
|
||||
}
|
||||
|
||||
|
||||
func testNoHeadMatch() {
|
||||
// No head match (only trim tail).
|
||||
let results_noheadmatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { $0 > 10 }
|
||||
XCTAssertEqual(results_noheadmatch, [1, 3, 5, 7, 9])
|
||||
let resultsNoHeadMatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { $0 > 10 }
|
||||
XCTAssertEqual(resultsNoHeadMatch, [1, 3, 5, 7, 9])
|
||||
}
|
||||
|
||||
|
||||
func testBothEndsMatch() {
|
||||
// Both ends match, some string of >1 elements do not (return that string).
|
||||
let results = [2, 10, 11, 15, 20, 21, 100].trimming { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(results, [11, 15, 20, 21])
|
||||
}
|
||||
|
||||
|
||||
func testEverythingMatches() {
|
||||
// Everything matches (trim everything).
|
||||
let results_allmatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { _ in true }
|
||||
XCTAssertEqual(results_allmatch, [])
|
||||
let resultsAllMatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { _ in true }
|
||||
XCTAssertEqual(resultsAllMatch, [])
|
||||
}
|
||||
|
||||
|
||||
func testEverythingButOneMatches() {
|
||||
// Both ends match, one element does not (trim all except that element).
|
||||
let results_one = [2, 10, 12, 15, 20, 100].trimming { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(results_one, [15])
|
||||
let resultsOne = [2, 10, 12, 15, 20, 100].trimming { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(resultsOne, [15])
|
||||
}
|
||||
|
||||
|
||||
func testTrimmingPrefix() {
|
||||
let results = [2, 10, 12, 15, 20, 100].trimmingPrefix { $0.isMultiple(of: 2) }
|
||||
let results = [2, 10, 12, 15, 20, 100].trimmingPrefix {
|
||||
$0.isMultiple(of: 2)
|
||||
}
|
||||
XCTAssertEqual(results, [15, 20, 100])
|
||||
}
|
||||
|
||||
|
||||
func testTrimmingSuffix() {
|
||||
let results = [2, 10, 12, 15, 20, 100].trimmingSuffix { $0.isMultiple(of: 2) }
|
||||
let results = [2, 10, 12, 15, 20, 100].trimmingSuffix {
|
||||
$0.isMultiple(of: 2)
|
||||
}
|
||||
XCTAssertEqual(results, [2, 10, 12, 15])
|
||||
}
|
||||
|
||||
|
||||
// Self == Self.Subsequence
|
||||
func testTrimNoAmbiguity() {
|
||||
var values = [2, 10, 12, 15, 20, 100] as ArraySlice
|
||||
values.trim { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(values, [15])
|
||||
}
|
||||
|
||||
|
||||
// Self == Self.Subsequence
|
||||
func testTrimPrefixNoAmbiguity() {
|
||||
var values = [2, 10, 12, 15, 20, 100] as ArraySlice
|
||||
values.trimPrefix { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(values, [15, 20, 100])
|
||||
}
|
||||
|
||||
|
||||
// Self == Self.Subsequence
|
||||
func testTrimSuffixNoAmbiguity() {
|
||||
var values = [2, 10, 12, 15, 20, 100] as ArraySlice
|
||||
|
||||
@@ -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,64 +23,70 @@ 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],
|
||||
],
|
||||
]
|
||||
}
|
||||
|
||||
extension UniquePermutationsTests {
|
||||
func testEmpty() {
|
||||
XCTAssertEqualSequences(([] as [Int]).uniquePermutations(), [[]])
|
||||
XCTAssertEqualSequences(([] as [Int]).uniquePermutations(ofCount: 0), [[]])
|
||||
XCTAssertEqualSequences(([] as [Int]).uniquePermutations(ofCount: 1), [])
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(([] as [Int]).uniquePermutations(), [[]])
|
||||
expectEqualSequences(([] as [Int]).uniquePermutations(ofCount: 0), [[]])
|
||||
expectEqualSequences(([] as [Int]).uniquePermutations(ofCount: 1), [])
|
||||
expectEqualSequences(
|
||||
([] as [Int]).uniquePermutations(ofCount: 1...3), [])
|
||||
}
|
||||
|
||||
|
||||
func testSingleCounts() {
|
||||
for (k, expectation) in Self.numbersPermutations.enumerated() {
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
expectation,
|
||||
Self.numbers.uniquePermutations(ofCount: k))
|
||||
}
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
|
||||
expectEqualSequences(
|
||||
Self.numbersPermutations[5],
|
||||
Self.numbers.uniquePermutations())
|
||||
}
|
||||
|
||||
|
||||
func testRanges() {
|
||||
for lower in Self.numbersPermutations.indices {
|
||||
// upper bounded
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
Self.numbersPermutations[...lower].joined(),
|
||||
Self.numbers.uniquePermutations(ofCount: ...lower))
|
||||
|
||||
|
||||
// lower bounded
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
Self.numbersPermutations[lower...].joined(),
|
||||
Self.numbers.uniquePermutations(ofCount: lower...))
|
||||
|
||||
for upper in lower..<Self.numbersPermutations.count {
|
||||
XCTAssertEqualSequences(
|
||||
expectEqualSequences(
|
||||
Self.numbersPermutations[lower..<upper].joined(),
|
||||
Self.numbers.uniquePermutations(ofCount: lower..<upper))
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -111,12 +117,13 @@ extension UniquePermutationsTests {
|
||||
let numbers = Self.numbers.map(IntBox.init)
|
||||
for k in 0...numbers.count {
|
||||
for p in numbers.uniquePermutations(ofCount: k) {
|
||||
XCTAssertTrue(p.filter { $0.value == 1 }.allSatisfy { $0 === numbers[0] })
|
||||
XCTAssertTrue(
|
||||
p.filter { $0.value == 1 }.allSatisfy { $0 === numbers[0] })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testLaziness() {
|
||||
XCTAssertLazySequence("ABCD".lazy.uniquePermutations())
|
||||
requireLazySequence("ABCD".lazy.uniquePermutations())
|
||||
}
|
||||
}
|
||||
@@ -9,8 +9,8 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class UniqueTests: XCTestCase {
|
||||
func testUnique() {
|
||||
@@ -18,36 +18,40 @@ 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 })
|
||||
XCTAssertEqualSequences(b, ["Albemarle", "Brandywine"])
|
||||
XCTAssertLazySequence(b)
|
||||
|
||||
let c: [Int] = []
|
||||
XCTAssertEqualSequences(c.lazy.uniqued(on: { $0.bitWidth }), [])
|
||||
|
||||
expectEqualSequences(c.uniqued(), [])
|
||||
|
||||
let d = Array(repeating: 1, count: 10)
|
||||
expectEqualSequences(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.lazy.uniqued(on: { $0.first }), ["Andromeda"])
|
||||
expectEqualSequences(d.uniqued(on: { $0.first }), ["Andromeda"])
|
||||
}
|
||||
|
||||
func testLazyUniqueOn() {
|
||||
let a = [
|
||||
"Albemarle", "Abeforth", "Astrology", "Brandywine", "Beatrice", "Axiom",
|
||||
]
|
||||
let b = a.lazy.uniqued(on: { $0.first })
|
||||
expectEqualSequences(b, ["Albemarle", "Brandywine"])
|
||||
requireLazySequence(b)
|
||||
|
||||
let c: [Int] = []
|
||||
expectEqualSequences(c.lazy.uniqued(on: { $0.bitWidth }), [])
|
||||
|
||||
let d = Array(repeating: "Andromeda", count: 10)
|
||||
expectEqualSequences(d.lazy.uniqued(on: { $0.first }), ["Andromeda"])
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
|
||||
@testable import Algorithms
|
||||
|
||||
final class WindowsTests: XCTestCase {
|
||||
@@ -18,73 +19,73 @@ final class WindowsTests: XCTestCase {
|
||||
let w = s.windows(ofCount: 2)
|
||||
var i = w.startIndex
|
||||
|
||||
XCTAssertEqualSequences(w[i], "sw")
|
||||
expectEqualSequences(w[i], "sw")
|
||||
w.formIndex(after: &i)
|
||||
XCTAssertEqualSequences(w[i], "wi")
|
||||
expectEqualSequences(w[i], "wi")
|
||||
w.formIndex(after: &i)
|
||||
XCTAssertEqualSequences(w[i], "if")
|
||||
expectEqualSequences(w[i], "if")
|
||||
w.formIndex(after: &i)
|
||||
XCTAssertEqualSequences(w[i], "ft")
|
||||
expectEqualSequences(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)
|
||||
|
||||
expectEqualSequences(w.first!, 0..<10)
|
||||
expectEqualSequences(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]()
|
||||
|
||||
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])
|
||||
|
||||
expectEqualSequences(snd, [1, 2, 3, 4])
|
||||
|
||||
let w2 = a.windows(ofCount: 3)
|
||||
XCTAssertEqualSequences(w2.last!, [3, 4, 5])
|
||||
expectEqualSequences(w2.last!, [3, 4, 5])
|
||||
}
|
||||
|
||||
|
||||
func testWindowsIndexAfterAndBefore() {
|
||||
let a = [0, 1, 2, 3, 4, 5].windows(ofCount: 2)
|
||||
var i = a.startIndex
|
||||
a.formIndex(after: &i)
|
||||
a.formIndex(after: &i)
|
||||
a.formIndex(before: &i)
|
||||
XCTAssertEqualSequences(a[i], [1, 2])
|
||||
expectEqualSequences(a[i], [1, 2])
|
||||
}
|
||||
|
||||
|
||||
func testWindowsIndexTraversals() {
|
||||
let validator = IndexValidator<WindowsOfCountCollection<String>>(
|
||||
indicesIncludingEnd: { windows in
|
||||
@@ -92,9 +93,9 @@ final class WindowsTests: XCTestCase {
|
||||
let indices = windows.base.indices + [endIndex]
|
||||
return zip(indices, indices.dropFirst(windows.windowSize))
|
||||
.map { .init(lowerBound: $0, upperBound: $1) }
|
||||
+ [.init(lowerBound: endIndex, upperBound: endIndex)]
|
||||
+ [.init(lowerBound: endIndex, upperBound: endIndex)]
|
||||
})
|
||||
|
||||
|
||||
validator.validate("".windows(ofCount: 1), expectedCount: 0)
|
||||
validator.validate("a".windows(ofCount: 1), expectedCount: 1)
|
||||
validator.validate("ab".windows(ofCount: 1), expectedCount: 2)
|
||||
@@ -106,6 +107,6 @@ final class WindowsTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testWindowsLazy() {
|
||||
XCTAssertLazyCollection([0, 1, 2, 3].lazy.windows(ofCount: 2))
|
||||
requireLazyCollection([0, 1, 2, 3].lazy.windows(ofCount: 2))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2023 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
PRODUCT_NAME = Algorithms
|
||||
PRODUCT_BUNDLE_IDENTIFIER = org.swift.Algorithms
|
||||
|
||||
SUPPORTED_PLATFORMS = macosx iphoneos iphonesimulator watchos watchsimulator appletvos appletvsimulator
|
||||
ARCHS = $(ARCHS_STANDARD)
|
||||
|
||||
MACOSX_DEPLOYMENT_TARGET = 12.0
|
||||
IPHONEOS_DEPLOYMENT_TARGET = 15.0
|
||||
WATCHOS_DEPLOYMENT_TARGET = 8.0
|
||||
TVOS_DEPLOYMENT_TARGET = 15.0
|
||||
|
||||
MARKETING_VERSION = 1.2
|
||||
|
||||
CURRENT_PROJECT_VERSION = 1
|
||||
VERSIONING_SYSTEM = apple-generic
|
||||
VERSION_INFO_PREFIX =
|
||||
DYLIB_COMPATIBILITY_VERSION = $(CURRENT_PROJECT_VERSION)
|
||||
DYLIB_CURRENT_VERSION = $(CURRENT_PROJECT_VERSION)
|
||||
|
||||
INSTALL_PATH = $(LOCAL_LIBRARY_DIR)/Frameworks
|
||||
SKIP_INSTALL = YES
|
||||
DYLIB_INSTALL_NAME_BASE = @rpath
|
||||
LD_RUNPATH_SEARCH_PATHS = $(inherited) @executable_path/../Frameworks @loader_path/Frameworks
|
||||
|
||||
ENABLE_TESTABILITY = NO
|
||||
ENABLE_TESTABILITY[config=Debug] = YES
|
||||
|
||||
GENERATE_INFOPLIST_FILE = YES
|
||||
@@ -0,0 +1,566 @@
|
||||
// !$*UTF8*$!
|
||||
{
|
||||
archiveVersion = 1;
|
||||
classes = {
|
||||
};
|
||||
objectVersion = 60;
|
||||
objects = {
|
||||
|
||||
/* Begin PBXBuildFile section */
|
||||
4347CECC2CE1D54900CD2979 /* Suffix.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA52CE1D54900CD2979 /* Suffix.swift */; };
|
||||
4347CECD2CE1D54900CD2979 /* Chunked.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE8F2CE1D54900CD2979 /* Chunked.swift */; };
|
||||
4347CECE2CE1D54900CD2979 /* Keyed.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE9B2CE1D54900CD2979 /* Keyed.swift */; };
|
||||
4347CECF2CE1D54900CD2979 /* Stride.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA42CE1D54900CD2979 /* Stride.swift */; };
|
||||
4347CED02CE1D54900CD2979 /* Windows.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA82CE1D54900CD2979 /* Windows.swift */; };
|
||||
4347CED32CE1D54900CD2979 /* Partition.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE9D2CE1D54900CD2979 /* Partition.swift */; };
|
||||
4347CED52CE1D54900CD2979 /* FirstNonNil.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE952CE1D54900CD2979 /* FirstNonNil.swift */; };
|
||||
4347CED62CE1D54900CD2979 /* Rotate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA22CE1D54900CD2979 /* Rotate.swift */; };
|
||||
4347CEDF2CE1D54900CD2979 /* Split.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA32CE1D54900CD2979 /* Split.swift */; };
|
||||
4347CEE02CE1D54900CD2979 /* Chain.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE8E2CE1D54900CD2979 /* Chain.swift */; };
|
||||
4347CEE12CE1D54900CD2979 /* Trim.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA62CE1D54900CD2979 /* Trim.swift */; };
|
||||
4347CEE22CE1D54900CD2979 /* Product.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE9F2CE1D54900CD2979 /* Product.swift */; };
|
||||
4347CEE42CE1D54900CD2979 /* Indexed.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE982CE1D54900CD2979 /* Indexed.swift */; };
|
||||
4347CEE52CE1D54900CD2979 /* Documentation.docc in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE932CE1D54900CD2979 /* Documentation.docc */; };
|
||||
4347CEE82CE1D54900CD2979 /* Combinations.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE902CE1D54900CD2979 /* Combinations.swift */; };
|
||||
4347CEE92CE1D54900CD2979 /* MinMax.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE9C2CE1D54900CD2979 /* MinMax.swift */; };
|
||||
4347CEEA2CE1D54900CD2979 /* Joined.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE9A2CE1D54900CD2979 /* Joined.swift */; };
|
||||
4347CEEB2CE1D54900CD2979 /* Grouped.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE972CE1D54900CD2979 /* Grouped.swift */; };
|
||||
4347CEED2CE1D54900CD2979 /* AdjacentPairs.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE8D2CE1D54900CD2979 /* AdjacentPairs.swift */; };
|
||||
4347CEEE2CE1D54900CD2979 /* Permutations.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE9E2CE1D54900CD2979 /* Permutations.swift */; };
|
||||
4347CEF02CE1D54900CD2979 /* FlattenCollection.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE962CE1D54900CD2979 /* FlattenCollection.swift */; };
|
||||
4347CEF32CE1D54900CD2979 /* Reductions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA12CE1D54900CD2979 /* Reductions.swift */; };
|
||||
4347CEF42CE1D54900CD2979 /* Intersperse.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE992CE1D54900CD2979 /* Intersperse.swift */; };
|
||||
4347CEF52CE1D54900CD2979 /* RandomSample.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA02CE1D54900CD2979 /* RandomSample.swift */; };
|
||||
4347CEFB2CE1D54900CD2979 /* Unique.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA72CE1D54900CD2979 /* Unique.swift */; };
|
||||
4347CEFD2CE1D54900CD2979 /* EitherSequence.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE942CE1D54900CD2979 /* EitherSequence.swift */; };
|
||||
4347CEFE2CE1D54900CD2979 /* Cycle.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE922CE1D54900CD2979 /* Cycle.swift */; };
|
||||
4347CEFF2CE1D54900CD2979 /* Compacted.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE912CE1D54900CD2979 /* Compacted.swift */; };
|
||||
4347CF262CE1D56C00CD2979 /* IndexedTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF112CE1D56C00CD2979 /* IndexedTests.swift */; };
|
||||
4347CF272CE1D56C00CD2979 /* RotateTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF1B2CE1D56C00CD2979 /* RotateTests.swift */; };
|
||||
4347CF282CE1D56C00CD2979 /* RandomSampleTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF192CE1D56C00CD2979 /* RandomSampleTests.swift */; };
|
||||
4347CF292CE1D56C00CD2979 /* StrideTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF1D2CE1D56C00CD2979 /* StrideTests.swift */; };
|
||||
4347CF2A2CE1D56C00CD2979 /* IntersperseTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF122CE1D56C00CD2979 /* IntersperseTests.swift */; };
|
||||
4347CF2B2CE1D56C00CD2979 /* CombinationsTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF0C2CE1D56C00CD2979 /* CombinationsTests.swift */; };
|
||||
4347CF2C2CE1D56C00CD2979 /* SplitTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF1C2CE1D56C00CD2979 /* SplitTests.swift */; };
|
||||
4347CF2D2CE1D56C00CD2979 /* ReductionsTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF1A2CE1D56C00CD2979 /* ReductionsTests.swift */; };
|
||||
4347CF2E2CE1D56C00CD2979 /* TrimTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF202CE1D56C00CD2979 /* TrimTests.swift */; };
|
||||
4347CF2F2CE1D56C00CD2979 /* FirstNonNilTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF0F2CE1D56C00CD2979 /* FirstNonNilTests.swift */; };
|
||||
4347CF302CE1D56C00CD2979 /* SuffixTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF1E2CE1D56C00CD2979 /* SuffixTests.swift */; };
|
||||
4347CF312CE1D56C00CD2979 /* KeyedTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF142CE1D56C00CD2979 /* KeyedTests.swift */; };
|
||||
4347CF322CE1D56C00CD2979 /* UniqueTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF222CE1D56C00CD2979 /* UniqueTests.swift */; };
|
||||
4347CF332CE1D56C00CD2979 /* PermutationsTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF172CE1D56C00CD2979 /* PermutationsTests.swift */; };
|
||||
4347CF342CE1D56C00CD2979 /* CompactedTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF0D2CE1D56C00CD2979 /* CompactedTests.swift */; };
|
||||
4347CF352CE1D56C00CD2979 /* UniquePermutationsTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF212CE1D56C00CD2979 /* UniquePermutationsTests.swift */; };
|
||||
4347CF362CE1D56C00CD2979 /* GroupedTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF102CE1D56C00CD2979 /* GroupedTests.swift */; };
|
||||
4347CF372CE1D56C00CD2979 /* MinMaxTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF152CE1D56C00CD2979 /* MinMaxTests.swift */; };
|
||||
4347CF382CE1D56C00CD2979 /* ProductTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF182CE1D56C00CD2979 /* ProductTests.swift */; };
|
||||
4347CF392CE1D56C00CD2979 /* ChainTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF0A2CE1D56C00CD2979 /* ChainTests.swift */; };
|
||||
4347CF3A2CE1D56C00CD2979 /* ChunkedTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF0B2CE1D56C00CD2979 /* ChunkedTests.swift */; };
|
||||
4347CF3B2CE1D56C00CD2979 /* PartitionTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF162CE1D56C00CD2979 /* PartitionTests.swift */; };
|
||||
4347CF3C2CE1D56C00CD2979 /* CycleTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF0E2CE1D56C00CD2979 /* CycleTests.swift */; };
|
||||
4347CF3D2CE1D56C00CD2979 /* AdjacentPairsTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF092CE1D56C00CD2979 /* AdjacentPairsTests.swift */; };
|
||||
4347CF3E2CE1D56C00CD2979 /* TestUtilities.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF1F2CE1D56C00CD2979 /* TestUtilities.swift */; };
|
||||
4347CF3F2CE1D56C00CD2979 /* WindowsTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF232CE1D56C00CD2979 /* WindowsTests.swift */; };
|
||||
4347CF402CE1D56C00CD2979 /* JoinedTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF132CE1D56C00CD2979 /* JoinedTests.swift */; };
|
||||
7D489E4829CE969D00499B21 /* Algorithms.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 7D489E3F29CE969D00499B21 /* Algorithms.framework */; };
|
||||
/* End PBXBuildFile section */
|
||||
|
||||
/* Begin PBXContainerItemProxy section */
|
||||
7D489E4929CE969D00499B21 /* PBXContainerItemProxy */ = {
|
||||
isa = PBXContainerItemProxy;
|
||||
containerPortal = 7D489E3629CE969D00499B21 /* Project object */;
|
||||
proxyType = 1;
|
||||
remoteGlobalIDString = 7D489E3E29CE969D00499B21;
|
||||
remoteInfo = Algorithms;
|
||||
};
|
||||
/* End PBXContainerItemProxy section */
|
||||
|
||||
/* Begin PBXFileReference section */
|
||||
4347CE862CE1D54900CD2979 /* CHANGELOG.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; name = CHANGELOG.md; path = ../CHANGELOG.md; sourceTree = SOURCE_ROOT; };
|
||||
4347CE872CE1D54900CD2979 /* CODE_OF_CONDUCT.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; name = CODE_OF_CONDUCT.md; path = ../CODE_OF_CONDUCT.md; sourceTree = SOURCE_ROOT; };
|
||||
4347CE882CE1D54900CD2979 /* CONTRIBUTING.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; name = CONTRIBUTING.md; path = ../CONTRIBUTING.md; sourceTree = SOURCE_ROOT; };
|
||||
4347CE892CE1D54900CD2979 /* LICENSE.txt */ = {isa = PBXFileReference; lastKnownFileType = text; name = LICENSE.txt; path = ../LICENSE.txt; sourceTree = SOURCE_ROOT; };
|
||||
4347CE8A2CE1D54900CD2979 /* Package.resolved */ = {isa = PBXFileReference; lastKnownFileType = text; name = Package.resolved; path = ../Package.resolved; sourceTree = SOURCE_ROOT; };
|
||||
4347CE8B2CE1D54900CD2979 /* Package.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = Package.swift; path = ../Package.swift; sourceTree = SOURCE_ROOT; };
|
||||
4347CE8C2CE1D54900CD2979 /* README.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; name = README.md; path = ../README.md; sourceTree = SOURCE_ROOT; };
|
||||
4347CE8D2CE1D54900CD2979 /* AdjacentPairs.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AdjacentPairs.swift; sourceTree = "<group>"; };
|
||||
4347CE8E2CE1D54900CD2979 /* Chain.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Chain.swift; sourceTree = "<group>"; };
|
||||
4347CE8F2CE1D54900CD2979 /* Chunked.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Chunked.swift; sourceTree = "<group>"; };
|
||||
4347CE902CE1D54900CD2979 /* Combinations.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Combinations.swift; sourceTree = "<group>"; };
|
||||
4347CE912CE1D54900CD2979 /* Compacted.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Compacted.swift; sourceTree = "<group>"; };
|
||||
4347CE922CE1D54900CD2979 /* Cycle.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Cycle.swift; sourceTree = "<group>"; };
|
||||
4347CE932CE1D54900CD2979 /* Documentation.docc */ = {isa = PBXFileReference; lastKnownFileType = folder.documentationcatalog; path = Documentation.docc; sourceTree = "<group>"; };
|
||||
4347CE942CE1D54900CD2979 /* EitherSequence.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = EitherSequence.swift; sourceTree = "<group>"; };
|
||||
4347CE952CE1D54900CD2979 /* FirstNonNil.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FirstNonNil.swift; sourceTree = "<group>"; };
|
||||
4347CE962CE1D54900CD2979 /* FlattenCollection.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FlattenCollection.swift; sourceTree = "<group>"; };
|
||||
4347CE972CE1D54900CD2979 /* Grouped.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Grouped.swift; sourceTree = "<group>"; };
|
||||
4347CE982CE1D54900CD2979 /* Indexed.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Indexed.swift; sourceTree = "<group>"; };
|
||||
4347CE992CE1D54900CD2979 /* Intersperse.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Intersperse.swift; sourceTree = "<group>"; };
|
||||
4347CE9A2CE1D54900CD2979 /* Joined.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Joined.swift; sourceTree = "<group>"; };
|
||||
4347CE9B2CE1D54900CD2979 /* Keyed.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Keyed.swift; sourceTree = "<group>"; };
|
||||
4347CE9C2CE1D54900CD2979 /* MinMax.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MinMax.swift; sourceTree = "<group>"; };
|
||||
4347CE9D2CE1D54900CD2979 /* Partition.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Partition.swift; sourceTree = "<group>"; };
|
||||
4347CE9E2CE1D54900CD2979 /* Permutations.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Permutations.swift; sourceTree = "<group>"; };
|
||||
4347CE9F2CE1D54900CD2979 /* Product.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Product.swift; sourceTree = "<group>"; };
|
||||
4347CEA02CE1D54900CD2979 /* RandomSample.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RandomSample.swift; sourceTree = "<group>"; };
|
||||
4347CEA12CE1D54900CD2979 /* Reductions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Reductions.swift; sourceTree = "<group>"; };
|
||||
4347CEA22CE1D54900CD2979 /* Rotate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Rotate.swift; sourceTree = "<group>"; };
|
||||
4347CEA32CE1D54900CD2979 /* Split.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Split.swift; sourceTree = "<group>"; };
|
||||
4347CEA42CE1D54900CD2979 /* Stride.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Stride.swift; sourceTree = "<group>"; };
|
||||
4347CEA52CE1D54900CD2979 /* Suffix.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Suffix.swift; sourceTree = "<group>"; };
|
||||
4347CEA62CE1D54900CD2979 /* Trim.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Trim.swift; sourceTree = "<group>"; };
|
||||
4347CEA72CE1D54900CD2979 /* Unique.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Unique.swift; sourceTree = "<group>"; };
|
||||
4347CEA82CE1D54900CD2979 /* Windows.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Windows.swift; sourceTree = "<group>"; };
|
||||
4347CEC82CE1D54900CD2979 /* swift-algorithms.xcworkspace */ = {isa = PBXFileReference; lastKnownFileType = wrapper.workspace; path = "swift-algorithms.xcworkspace"; sourceTree = "<group>"; };
|
||||
4347CF092CE1D56C00CD2979 /* AdjacentPairsTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AdjacentPairsTests.swift; sourceTree = "<group>"; };
|
||||
4347CF0A2CE1D56C00CD2979 /* ChainTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ChainTests.swift; sourceTree = "<group>"; };
|
||||
4347CF0B2CE1D56C00CD2979 /* ChunkedTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ChunkedTests.swift; sourceTree = "<group>"; };
|
||||
4347CF0C2CE1D56C00CD2979 /* CombinationsTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CombinationsTests.swift; sourceTree = "<group>"; };
|
||||
4347CF0D2CE1D56C00CD2979 /* CompactedTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CompactedTests.swift; sourceTree = "<group>"; };
|
||||
4347CF0E2CE1D56C00CD2979 /* CycleTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CycleTests.swift; sourceTree = "<group>"; };
|
||||
4347CF0F2CE1D56C00CD2979 /* FirstNonNilTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FirstNonNilTests.swift; sourceTree = "<group>"; };
|
||||
4347CF102CE1D56C00CD2979 /* GroupedTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GroupedTests.swift; sourceTree = "<group>"; };
|
||||
4347CF112CE1D56C00CD2979 /* IndexedTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = IndexedTests.swift; sourceTree = "<group>"; };
|
||||
4347CF122CE1D56C00CD2979 /* IntersperseTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = IntersperseTests.swift; sourceTree = "<group>"; };
|
||||
4347CF132CE1D56C00CD2979 /* JoinedTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JoinedTests.swift; sourceTree = "<group>"; };
|
||||
4347CF142CE1D56C00CD2979 /* KeyedTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = KeyedTests.swift; sourceTree = "<group>"; };
|
||||
4347CF152CE1D56C00CD2979 /* MinMaxTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MinMaxTests.swift; sourceTree = "<group>"; };
|
||||
4347CF162CE1D56C00CD2979 /* PartitionTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PartitionTests.swift; sourceTree = "<group>"; };
|
||||
4347CF172CE1D56C00CD2979 /* PermutationsTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PermutationsTests.swift; sourceTree = "<group>"; };
|
||||
4347CF182CE1D56C00CD2979 /* ProductTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ProductTests.swift; sourceTree = "<group>"; };
|
||||
4347CF192CE1D56C00CD2979 /* RandomSampleTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RandomSampleTests.swift; sourceTree = "<group>"; };
|
||||
4347CF1A2CE1D56C00CD2979 /* ReductionsTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ReductionsTests.swift; sourceTree = "<group>"; };
|
||||
4347CF1B2CE1D56C00CD2979 /* RotateTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RotateTests.swift; sourceTree = "<group>"; };
|
||||
4347CF1C2CE1D56C00CD2979 /* SplitTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SplitTests.swift; sourceTree = "<group>"; };
|
||||
4347CF1D2CE1D56C00CD2979 /* StrideTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = StrideTests.swift; sourceTree = "<group>"; };
|
||||
4347CF1E2CE1D56C00CD2979 /* SuffixTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SuffixTests.swift; sourceTree = "<group>"; };
|
||||
4347CF1F2CE1D56C00CD2979 /* TestUtilities.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TestUtilities.swift; sourceTree = "<group>"; };
|
||||
4347CF202CE1D56C00CD2979 /* TrimTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TrimTests.swift; sourceTree = "<group>"; };
|
||||
4347CF212CE1D56C00CD2979 /* UniquePermutationsTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UniquePermutationsTests.swift; sourceTree = "<group>"; };
|
||||
4347CF222CE1D56C00CD2979 /* UniqueTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UniqueTests.swift; sourceTree = "<group>"; };
|
||||
4347CF232CE1D56C00CD2979 /* WindowsTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = WindowsTests.swift; sourceTree = "<group>"; };
|
||||
7D489E3F29CE969D00499B21 /* Algorithms.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Algorithms.framework; sourceTree = BUILT_PRODUCTS_DIR; };
|
||||
7D489E4729CE969D00499B21 /* AlgorithmsTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = AlgorithmsTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
|
||||
7D489ED629CE96DA00499B21 /* README.md */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = net.daringfireball.markdown; path = README.md; sourceTree = "<group>"; };
|
||||
7D489F6F29CE986A00499B21 /* Shared.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Shared.xcconfig; sourceTree = "<group>"; };
|
||||
7D489F7029CE986A00499B21 /* Algorithms.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Algorithms.xcconfig; sourceTree = "<group>"; };
|
||||
7D489F7129CE986A00499B21 /* AlgorithmsTests.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = AlgorithmsTests.xcconfig; sourceTree = "<group>"; };
|
||||
BB63DC6A29D782010054E9C2 /* Algorithms.xctestplan */ = {isa = PBXFileReference; lastKnownFileType = text; path = Algorithms.xctestplan; sourceTree = "<group>"; };
|
||||
/* End PBXFileReference section */
|
||||
|
||||
/* Begin PBXFrameworksBuildPhase section */
|
||||
7D489E3C29CE969D00499B21 /* Frameworks */ = {
|
||||
isa = PBXFrameworksBuildPhase;
|
||||
buildActionMask = 2147483647;
|
||||
files = (
|
||||
);
|
||||
runOnlyForDeploymentPostprocessing = 0;
|
||||
};
|
||||
7D489E4429CE969D00499B21 /* Frameworks */ = {
|
||||
isa = PBXFrameworksBuildPhase;
|
||||
buildActionMask = 2147483647;
|
||||
files = (
|
||||
7D489E4829CE969D00499B21 /* Algorithms.framework in Frameworks */,
|
||||
);
|
||||
runOnlyForDeploymentPostprocessing = 0;
|
||||
};
|
||||
/* End PBXFrameworksBuildPhase section */
|
||||
|
||||
/* Begin PBXGroup section */
|
||||
4347CEA92CE1D54900CD2979 /* Algorithms */ = {
|
||||
isa = PBXGroup;
|
||||
children = (
|
||||
4347CE8D2CE1D54900CD2979 /* AdjacentPairs.swift */,
|
||||
4347CE8E2CE1D54900CD2979 /* Chain.swift */,
|
||||
4347CE8F2CE1D54900CD2979 /* Chunked.swift */,
|
||||
4347CE902CE1D54900CD2979 /* Combinations.swift */,
|
||||
4347CE912CE1D54900CD2979 /* Compacted.swift */,
|
||||
4347CE922CE1D54900CD2979 /* Cycle.swift */,
|
||||
4347CE932CE1D54900CD2979 /* Documentation.docc */,
|
||||
4347CE942CE1D54900CD2979 /* EitherSequence.swift */,
|
||||
4347CE952CE1D54900CD2979 /* FirstNonNil.swift */,
|
||||
4347CE962CE1D54900CD2979 /* FlattenCollection.swift */,
|
||||
4347CE972CE1D54900CD2979 /* Grouped.swift */,
|
||||
4347CE982CE1D54900CD2979 /* Indexed.swift */,
|
||||
4347CE992CE1D54900CD2979 /* Intersperse.swift */,
|
||||
4347CE9A2CE1D54900CD2979 /* Joined.swift */,
|
||||
4347CE9B2CE1D54900CD2979 /* Keyed.swift */,
|
||||
4347CE9C2CE1D54900CD2979 /* MinMax.swift */,
|
||||
4347CE9D2CE1D54900CD2979 /* Partition.swift */,
|
||||
4347CE9E2CE1D54900CD2979 /* Permutations.swift */,
|
||||
4347CE9F2CE1D54900CD2979 /* Product.swift */,
|
||||
4347CEA02CE1D54900CD2979 /* RandomSample.swift */,
|
||||
4347CEA12CE1D54900CD2979 /* Reductions.swift */,
|
||||
4347CEA22CE1D54900CD2979 /* Rotate.swift */,
|
||||
4347CEA32CE1D54900CD2979 /* Split.swift */,
|
||||
4347CEA42CE1D54900CD2979 /* Stride.swift */,
|
||||
4347CEA52CE1D54900CD2979 /* Suffix.swift */,
|
||||
4347CEA62CE1D54900CD2979 /* Trim.swift */,
|
||||
4347CEA72CE1D54900CD2979 /* Unique.swift */,
|
||||
4347CEA82CE1D54900CD2979 /* Windows.swift */,
|
||||
);
|
||||
path = Algorithms;
|
||||
sourceTree = "<group>";
|
||||
};
|
||||
4347CEAA2CE1D54900CD2979 /* Sources */ = {
|
||||
isa = PBXGroup;
|
||||
children = (
|
||||
4347CEA92CE1D54900CD2979 /* Algorithms */,
|
||||
);
|
||||
name = Sources;
|
||||
path = ../Sources;
|
||||
sourceTree = SOURCE_ROOT;
|
||||
};
|
||||
4347CEC92CE1D54900CD2979 /* Tools */ = {
|
||||
isa = PBXGroup;
|
||||
children = (
|
||||
4347CEC82CE1D54900CD2979 /* swift-algorithms.xcworkspace */,
|
||||
);
|
||||
name = Tools;
|
||||
path = ../Tools;
|
||||
sourceTree = SOURCE_ROOT;
|
||||
};
|
||||
4347CF242CE1D56C00CD2979 /* SwiftAlgorithmsTests */ = {
|
||||
isa = PBXGroup;
|
||||
children = (
|
||||
4347CF092CE1D56C00CD2979 /* AdjacentPairsTests.swift */,
|
||||
4347CF0A2CE1D56C00CD2979 /* ChainTests.swift */,
|
||||
4347CF0B2CE1D56C00CD2979 /* ChunkedTests.swift */,
|
||||
4347CF0C2CE1D56C00CD2979 /* CombinationsTests.swift */,
|
||||
4347CF0D2CE1D56C00CD2979 /* CompactedTests.swift */,
|
||||
4347CF0E2CE1D56C00CD2979 /* CycleTests.swift */,
|
||||
4347CF0F2CE1D56C00CD2979 /* FirstNonNilTests.swift */,
|
||||
4347CF102CE1D56C00CD2979 /* GroupedTests.swift */,
|
||||
4347CF112CE1D56C00CD2979 /* IndexedTests.swift */,
|
||||
4347CF122CE1D56C00CD2979 /* IntersperseTests.swift */,
|
||||
4347CF132CE1D56C00CD2979 /* JoinedTests.swift */,
|
||||
4347CF142CE1D56C00CD2979 /* KeyedTests.swift */,
|
||||
4347CF152CE1D56C00CD2979 /* MinMaxTests.swift */,
|
||||
4347CF162CE1D56C00CD2979 /* PartitionTests.swift */,
|
||||
4347CF172CE1D56C00CD2979 /* PermutationsTests.swift */,
|
||||
4347CF182CE1D56C00CD2979 /* ProductTests.swift */,
|
||||
4347CF192CE1D56C00CD2979 /* RandomSampleTests.swift */,
|
||||
4347CF1A2CE1D56C00CD2979 /* ReductionsTests.swift */,
|
||||
4347CF1B2CE1D56C00CD2979 /* RotateTests.swift */,
|
||||
4347CF1C2CE1D56C00CD2979 /* SplitTests.swift */,
|
||||
4347CF1D2CE1D56C00CD2979 /* StrideTests.swift */,
|
||||
4347CF1E2CE1D56C00CD2979 /* SuffixTests.swift */,
|
||||
4347CF1F2CE1D56C00CD2979 /* TestUtilities.swift */,
|
||||
4347CF202CE1D56C00CD2979 /* TrimTests.swift */,
|
||||
4347CF212CE1D56C00CD2979 /* UniquePermutationsTests.swift */,
|
||||
4347CF222CE1D56C00CD2979 /* UniqueTests.swift */,
|
||||
4347CF232CE1D56C00CD2979 /* WindowsTests.swift */,
|
||||
);
|
||||
path = SwiftAlgorithmsTests;
|
||||
sourceTree = "<group>";
|
||||
};
|
||||
4347CF252CE1D56C00CD2979 /* Tests */ = {
|
||||
isa = PBXGroup;
|
||||
children = (
|
||||
4347CF242CE1D56C00CD2979 /* SwiftAlgorithmsTests */,
|
||||
);
|
||||
name = Tests;
|
||||
path = ../Tests;
|
||||
sourceTree = SOURCE_ROOT;
|
||||
};
|
||||
7D489E3529CE969D00499B21 = {
|
||||
isa = PBXGroup;
|
||||
children = (
|
||||
4347CE862CE1D54900CD2979 /* CHANGELOG.md */,
|
||||
4347CE872CE1D54900CD2979 /* CODE_OF_CONDUCT.md */,
|
||||
4347CE882CE1D54900CD2979 /* CONTRIBUTING.md */,
|
||||
4347CE892CE1D54900CD2979 /* LICENSE.txt */,
|
||||
4347CE8A2CE1D54900CD2979 /* Package.resolved */,
|
||||
4347CE8B2CE1D54900CD2979 /* Package.swift */,
|
||||
4347CE8C2CE1D54900CD2979 /* README.md */,
|
||||
4347CEAA2CE1D54900CD2979 /* Sources */,
|
||||
4347CF252CE1D56C00CD2979 /* Tests */,
|
||||
4347CEC92CE1D54900CD2979 /* Tools */,
|
||||
7D489ED229CE96DA00499B21 /* Xcode */,
|
||||
7D489E4029CE969D00499B21 /* Products */,
|
||||
);
|
||||
sourceTree = "<group>";
|
||||
tabWidth = 8;
|
||||
};
|
||||
7D489E4029CE969D00499B21 /* Products */ = {
|
||||
isa = PBXGroup;
|
||||
children = (
|
||||
7D489E3F29CE969D00499B21 /* Algorithms.framework */,
|
||||
7D489E4729CE969D00499B21 /* AlgorithmsTests.xctest */,
|
||||
);
|
||||
name = Products;
|
||||
sourceTree = "<group>";
|
||||
};
|
||||
7D489ED229CE96DA00499B21 /* Xcode */ = {
|
||||
isa = PBXGroup;
|
||||
children = (
|
||||
BB63DC6A29D782010054E9C2 /* Algorithms.xctestplan */,
|
||||
7D489F6F29CE986A00499B21 /* Shared.xcconfig */,
|
||||
7D489F7029CE986A00499B21 /* Algorithms.xcconfig */,
|
||||
7D489F7129CE986A00499B21 /* AlgorithmsTests.xcconfig */,
|
||||
7D489ED629CE96DA00499B21 /* README.md */,
|
||||
);
|
||||
name = Xcode;
|
||||
sourceTree = "<group>";
|
||||
};
|
||||
/* End PBXGroup section */
|
||||
|
||||
/* Begin PBXHeadersBuildPhase section */
|
||||
7D489E3A29CE969D00499B21 /* Headers */ = {
|
||||
isa = PBXHeadersBuildPhase;
|
||||
buildActionMask = 2147483647;
|
||||
files = (
|
||||
);
|
||||
runOnlyForDeploymentPostprocessing = 0;
|
||||
};
|
||||
/* End PBXHeadersBuildPhase section */
|
||||
|
||||
/* Begin PBXNativeTarget section */
|
||||
7D489E3E29CE969D00499B21 /* Algorithms */ = {
|
||||
isa = PBXNativeTarget;
|
||||
buildConfigurationList = 7D489E5129CE969D00499B21 /* Build configuration list for PBXNativeTarget "Algorithms" */;
|
||||
buildPhases = (
|
||||
7D489E3A29CE969D00499B21 /* Headers */,
|
||||
7D489E3B29CE969D00499B21 /* Sources */,
|
||||
7D489E3C29CE969D00499B21 /* Frameworks */,
|
||||
7D489E3D29CE969D00499B21 /* Resources */,
|
||||
);
|
||||
buildRules = (
|
||||
);
|
||||
dependencies = (
|
||||
);
|
||||
name = Algorithms;
|
||||
productName = Algorithms;
|
||||
productReference = 7D489E3F29CE969D00499B21 /* Algorithms.framework */;
|
||||
productType = "com.apple.product-type.framework";
|
||||
};
|
||||
7D489E4629CE969D00499B21 /* AlgorithmsTests */ = {
|
||||
isa = PBXNativeTarget;
|
||||
buildConfigurationList = 7D489E5429CE969D00499B21 /* Build configuration list for PBXNativeTarget "AlgorithmsTests" */;
|
||||
buildPhases = (
|
||||
7D489E4329CE969D00499B21 /* Sources */,
|
||||
7D489E4429CE969D00499B21 /* Frameworks */,
|
||||
7D489E4529CE969D00499B21 /* Resources */,
|
||||
);
|
||||
buildRules = (
|
||||
);
|
||||
dependencies = (
|
||||
7D489E4A29CE969D00499B21 /* PBXTargetDependency */,
|
||||
);
|
||||
name = AlgorithmsTests;
|
||||
productName = AlgorithmsTests;
|
||||
productReference = 7D489E4729CE969D00499B21 /* AlgorithmsTests.xctest */;
|
||||
productType = "com.apple.product-type.bundle.unit-test";
|
||||
};
|
||||
/* End PBXNativeTarget section */
|
||||
|
||||
/* Begin PBXProject section */
|
||||
7D489E3629CE969D00499B21 /* Project object */ = {
|
||||
isa = PBXProject;
|
||||
attributes = {
|
||||
BuildIndependentTargetsInParallel = 1;
|
||||
LastSwiftUpdateCheck = 1420;
|
||||
LastUpgradeCheck = 1500;
|
||||
TargetAttributes = {
|
||||
7D489E3E29CE969D00499B21 = {
|
||||
CreatedOnToolsVersion = 14.2;
|
||||
LastSwiftMigration = 1420;
|
||||
};
|
||||
7D489E4629CE969D00499B21 = {
|
||||
CreatedOnToolsVersion = 14.2;
|
||||
};
|
||||
};
|
||||
};
|
||||
buildConfigurationList = 7D489E3929CE969D00499B21 /* Build configuration list for PBXProject "Algorithms" */;
|
||||
compatibilityVersion = "Xcode 15.0";
|
||||
developmentRegion = en;
|
||||
hasScannedForEncodings = 0;
|
||||
knownRegions = (
|
||||
en,
|
||||
Base,
|
||||
);
|
||||
mainGroup = 7D489E3529CE969D00499B21;
|
||||
productRefGroup = 7D489E4029CE969D00499B21 /* Products */;
|
||||
projectDirPath = "";
|
||||
projectRoot = "";
|
||||
targets = (
|
||||
7D489E3E29CE969D00499B21 /* Algorithms */,
|
||||
7D489E4629CE969D00499B21 /* AlgorithmsTests */,
|
||||
);
|
||||
};
|
||||
/* End PBXProject section */
|
||||
|
||||
/* Begin PBXResourcesBuildPhase section */
|
||||
7D489E3D29CE969D00499B21 /* Resources */ = {
|
||||
isa = PBXResourcesBuildPhase;
|
||||
buildActionMask = 2147483647;
|
||||
files = (
|
||||
);
|
||||
runOnlyForDeploymentPostprocessing = 0;
|
||||
};
|
||||
7D489E4529CE969D00499B21 /* Resources */ = {
|
||||
isa = PBXResourcesBuildPhase;
|
||||
buildActionMask = 2147483647;
|
||||
files = (
|
||||
);
|
||||
runOnlyForDeploymentPostprocessing = 0;
|
||||
};
|
||||
/* End PBXResourcesBuildPhase section */
|
||||
|
||||
/* Begin PBXSourcesBuildPhase section */
|
||||
7D489E3B29CE969D00499B21 /* Sources */ = {
|
||||
isa = PBXSourcesBuildPhase;
|
||||
buildActionMask = 2147483647;
|
||||
files = (
|
||||
4347CECC2CE1D54900CD2979 /* Suffix.swift in Sources */,
|
||||
4347CECD2CE1D54900CD2979 /* Chunked.swift in Sources */,
|
||||
4347CECE2CE1D54900CD2979 /* Keyed.swift in Sources */,
|
||||
4347CECF2CE1D54900CD2979 /* Stride.swift in Sources */,
|
||||
4347CED02CE1D54900CD2979 /* Windows.swift in Sources */,
|
||||
4347CED32CE1D54900CD2979 /* Partition.swift in Sources */,
|
||||
4347CED52CE1D54900CD2979 /* FirstNonNil.swift in Sources */,
|
||||
4347CED62CE1D54900CD2979 /* Rotate.swift in Sources */,
|
||||
4347CEDF2CE1D54900CD2979 /* Split.swift in Sources */,
|
||||
4347CEE02CE1D54900CD2979 /* Chain.swift in Sources */,
|
||||
4347CEE12CE1D54900CD2979 /* Trim.swift in Sources */,
|
||||
4347CEE22CE1D54900CD2979 /* Product.swift in Sources */,
|
||||
4347CEE42CE1D54900CD2979 /* Indexed.swift in Sources */,
|
||||
4347CEE52CE1D54900CD2979 /* Documentation.docc in Sources */,
|
||||
4347CEE82CE1D54900CD2979 /* Combinations.swift in Sources */,
|
||||
4347CEE92CE1D54900CD2979 /* MinMax.swift in Sources */,
|
||||
4347CEEA2CE1D54900CD2979 /* Joined.swift in Sources */,
|
||||
4347CEEB2CE1D54900CD2979 /* Grouped.swift in Sources */,
|
||||
4347CEED2CE1D54900CD2979 /* AdjacentPairs.swift in Sources */,
|
||||
4347CEEE2CE1D54900CD2979 /* Permutations.swift in Sources */,
|
||||
4347CEF02CE1D54900CD2979 /* FlattenCollection.swift in Sources */,
|
||||
4347CEF32CE1D54900CD2979 /* Reductions.swift in Sources */,
|
||||
4347CEF42CE1D54900CD2979 /* Intersperse.swift in Sources */,
|
||||
4347CEF52CE1D54900CD2979 /* RandomSample.swift in Sources */,
|
||||
4347CEFB2CE1D54900CD2979 /* Unique.swift in Sources */,
|
||||
4347CEFD2CE1D54900CD2979 /* EitherSequence.swift in Sources */,
|
||||
4347CEFE2CE1D54900CD2979 /* Cycle.swift in Sources */,
|
||||
4347CEFF2CE1D54900CD2979 /* Compacted.swift in Sources */,
|
||||
);
|
||||
runOnlyForDeploymentPostprocessing = 0;
|
||||
};
|
||||
7D489E4329CE969D00499B21 /* Sources */ = {
|
||||
isa = PBXSourcesBuildPhase;
|
||||
buildActionMask = 2147483647;
|
||||
files = (
|
||||
4347CF262CE1D56C00CD2979 /* IndexedTests.swift in Sources */,
|
||||
4347CF272CE1D56C00CD2979 /* RotateTests.swift in Sources */,
|
||||
4347CF282CE1D56C00CD2979 /* RandomSampleTests.swift in Sources */,
|
||||
4347CF292CE1D56C00CD2979 /* StrideTests.swift in Sources */,
|
||||
4347CF2A2CE1D56C00CD2979 /* IntersperseTests.swift in Sources */,
|
||||
4347CF2B2CE1D56C00CD2979 /* CombinationsTests.swift in Sources */,
|
||||
4347CF2C2CE1D56C00CD2979 /* SplitTests.swift in Sources */,
|
||||
4347CF2D2CE1D56C00CD2979 /* ReductionsTests.swift in Sources */,
|
||||
4347CF2E2CE1D56C00CD2979 /* TrimTests.swift in Sources */,
|
||||
4347CF2F2CE1D56C00CD2979 /* FirstNonNilTests.swift in Sources */,
|
||||
4347CF302CE1D56C00CD2979 /* SuffixTests.swift in Sources */,
|
||||
4347CF312CE1D56C00CD2979 /* KeyedTests.swift in Sources */,
|
||||
4347CF322CE1D56C00CD2979 /* UniqueTests.swift in Sources */,
|
||||
4347CF332CE1D56C00CD2979 /* PermutationsTests.swift in Sources */,
|
||||
4347CF342CE1D56C00CD2979 /* CompactedTests.swift in Sources */,
|
||||
4347CF352CE1D56C00CD2979 /* UniquePermutationsTests.swift in Sources */,
|
||||
4347CF362CE1D56C00CD2979 /* GroupedTests.swift in Sources */,
|
||||
4347CF372CE1D56C00CD2979 /* MinMaxTests.swift in Sources */,
|
||||
4347CF382CE1D56C00CD2979 /* ProductTests.swift in Sources */,
|
||||
4347CF392CE1D56C00CD2979 /* ChainTests.swift in Sources */,
|
||||
4347CF3A2CE1D56C00CD2979 /* ChunkedTests.swift in Sources */,
|
||||
4347CF3B2CE1D56C00CD2979 /* PartitionTests.swift in Sources */,
|
||||
4347CF3C2CE1D56C00CD2979 /* CycleTests.swift in Sources */,
|
||||
4347CF3D2CE1D56C00CD2979 /* AdjacentPairsTests.swift in Sources */,
|
||||
4347CF3E2CE1D56C00CD2979 /* TestUtilities.swift in Sources */,
|
||||
4347CF3F2CE1D56C00CD2979 /* WindowsTests.swift in Sources */,
|
||||
4347CF402CE1D56C00CD2979 /* JoinedTests.swift in Sources */,
|
||||
);
|
||||
runOnlyForDeploymentPostprocessing = 0;
|
||||
};
|
||||
/* End PBXSourcesBuildPhase section */
|
||||
|
||||
/* Begin PBXTargetDependency section */
|
||||
7D489E4A29CE969D00499B21 /* PBXTargetDependency */ = {
|
||||
isa = PBXTargetDependency;
|
||||
target = 7D489E3E29CE969D00499B21 /* Algorithms */;
|
||||
targetProxy = 7D489E4929CE969D00499B21 /* PBXContainerItemProxy */;
|
||||
};
|
||||
/* End PBXTargetDependency section */
|
||||
|
||||
/* Begin XCBuildConfiguration section */
|
||||
7D489E4F29CE969D00499B21 /* Debug */ = {
|
||||
isa = XCBuildConfiguration;
|
||||
baseConfigurationReference = 7D489F6F29CE986A00499B21 /* Shared.xcconfig */;
|
||||
buildSettings = {
|
||||
};
|
||||
name = Debug;
|
||||
};
|
||||
7D489E5029CE969D00499B21 /* Release */ = {
|
||||
isa = XCBuildConfiguration;
|
||||
baseConfigurationReference = 7D489F6F29CE986A00499B21 /* Shared.xcconfig */;
|
||||
buildSettings = {
|
||||
};
|
||||
name = Release;
|
||||
};
|
||||
7D489E5229CE969D00499B21 /* Debug */ = {
|
||||
isa = XCBuildConfiguration;
|
||||
baseConfigurationReference = 7D489F7029CE986A00499B21 /* Algorithms.xcconfig */;
|
||||
buildSettings = {
|
||||
};
|
||||
name = Debug;
|
||||
};
|
||||
7D489E5329CE969D00499B21 /* Release */ = {
|
||||
isa = XCBuildConfiguration;
|
||||
baseConfigurationReference = 7D489F7029CE986A00499B21 /* Algorithms.xcconfig */;
|
||||
buildSettings = {
|
||||
};
|
||||
name = Release;
|
||||
};
|
||||
7D489E5529CE969D00499B21 /* Debug */ = {
|
||||
isa = XCBuildConfiguration;
|
||||
baseConfigurationReference = 7D489F7129CE986A00499B21 /* AlgorithmsTests.xcconfig */;
|
||||
buildSettings = {
|
||||
};
|
||||
name = Debug;
|
||||
};
|
||||
7D489E5629CE969D00499B21 /* Release */ = {
|
||||
isa = XCBuildConfiguration;
|
||||
baseConfigurationReference = 7D489F7129CE986A00499B21 /* AlgorithmsTests.xcconfig */;
|
||||
buildSettings = {
|
||||
};
|
||||
name = Release;
|
||||
};
|
||||
/* End XCBuildConfiguration section */
|
||||
|
||||
/* Begin XCConfigurationList section */
|
||||
7D489E3929CE969D00499B21 /* Build configuration list for PBXProject "Algorithms" */ = {
|
||||
isa = XCConfigurationList;
|
||||
buildConfigurations = (
|
||||
7D489E4F29CE969D00499B21 /* Debug */,
|
||||
7D489E5029CE969D00499B21 /* Release */,
|
||||
);
|
||||
defaultConfigurationIsVisible = 0;
|
||||
defaultConfigurationName = Release;
|
||||
};
|
||||
7D489E5129CE969D00499B21 /* Build configuration list for PBXNativeTarget "Algorithms" */ = {
|
||||
isa = XCConfigurationList;
|
||||
buildConfigurations = (
|
||||
7D489E5229CE969D00499B21 /* Debug */,
|
||||
7D489E5329CE969D00499B21 /* Release */,
|
||||
);
|
||||
defaultConfigurationIsVisible = 0;
|
||||
defaultConfigurationName = Release;
|
||||
};
|
||||
7D489E5429CE969D00499B21 /* Build configuration list for PBXNativeTarget "AlgorithmsTests" */ = {
|
||||
isa = XCConfigurationList;
|
||||
buildConfigurations = (
|
||||
7D489E5529CE969D00499B21 /* Debug */,
|
||||
7D489E5629CE969D00499B21 /* Release */,
|
||||
);
|
||||
defaultConfigurationIsVisible = 0;
|
||||
defaultConfigurationName = Release;
|
||||
};
|
||||
/* End XCConfigurationList section */
|
||||
};
|
||||
rootObject = 7D489E3629CE969D00499B21 /* Project object */;
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Workspace
|
||||
version = "1.0">
|
||||
<FileRef
|
||||
location = "self:">
|
||||
</FileRef>
|
||||
</Workspace>
|
||||
@@ -0,0 +1,8 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
||||
<plist version="1.0">
|
||||
<dict>
|
||||
<key>IDEDidComputeMac32BitWarning</key>
|
||||
<true/>
|
||||
</dict>
|
||||
</plist>
|
||||
@@ -0,0 +1,84 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Scheme
|
||||
LastUpgradeVersion = "1500"
|
||||
version = "1.7">
|
||||
<BuildAction
|
||||
parallelizeBuildables = "YES"
|
||||
buildImplicitDependencies = "YES">
|
||||
<BuildActionEntries>
|
||||
<BuildActionEntry
|
||||
buildForTesting = "YES"
|
||||
buildForRunning = "YES"
|
||||
buildForProfiling = "YES"
|
||||
buildForArchiving = "YES"
|
||||
buildForAnalyzing = "YES">
|
||||
<BuildableReference
|
||||
BuildableIdentifier = "primary"
|
||||
BlueprintIdentifier = "7D489E3E29CE969D00499B21"
|
||||
BuildableName = "Algorithms.framework"
|
||||
BlueprintName = "Algorithms"
|
||||
ReferencedContainer = "container:Algorithms.xcodeproj">
|
||||
</BuildableReference>
|
||||
</BuildActionEntry>
|
||||
</BuildActionEntries>
|
||||
</BuildAction>
|
||||
<TestAction
|
||||
buildConfiguration = "Debug"
|
||||
selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
|
||||
selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
|
||||
shouldUseLaunchSchemeArgsEnv = "YES">
|
||||
<TestPlans>
|
||||
<TestPlanReference
|
||||
reference = "container:Algorithms.xctestplan"
|
||||
default = "YES">
|
||||
</TestPlanReference>
|
||||
</TestPlans>
|
||||
<Testables>
|
||||
<TestableReference
|
||||
skipped = "NO"
|
||||
parallelizable = "YES">
|
||||
<BuildableReference
|
||||
BuildableIdentifier = "primary"
|
||||
BlueprintIdentifier = "7D489E4629CE969D00499B21"
|
||||
BuildableName = "AlgorithmsTests.xctest"
|
||||
BlueprintName = "AlgorithmsTests"
|
||||
ReferencedContainer = "container:Algorithms.xcodeproj">
|
||||
</BuildableReference>
|
||||
</TestableReference>
|
||||
</Testables>
|
||||
</TestAction>
|
||||
<LaunchAction
|
||||
buildConfiguration = "Debug"
|
||||
selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
|
||||
selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
|
||||
launchStyle = "0"
|
||||
useCustomWorkingDirectory = "NO"
|
||||
ignoresPersistentStateOnLaunch = "NO"
|
||||
debugDocumentVersioning = "YES"
|
||||
debugServiceExtension = "internal"
|
||||
allowLocationSimulation = "YES">
|
||||
</LaunchAction>
|
||||
<ProfileAction
|
||||
buildConfiguration = "Release"
|
||||
shouldUseLaunchSchemeArgsEnv = "YES"
|
||||
savedToolIdentifier = ""
|
||||
useCustomWorkingDirectory = "NO"
|
||||
debugDocumentVersioning = "YES">
|
||||
<MacroExpansion>
|
||||
<BuildableReference
|
||||
BuildableIdentifier = "primary"
|
||||
BlueprintIdentifier = "7D489E3E29CE969D00499B21"
|
||||
BuildableName = "Algorithms.framework"
|
||||
BlueprintName = "Algorithms"
|
||||
ReferencedContainer = "container:Algorithms.xcodeproj">
|
||||
</BuildableReference>
|
||||
</MacroExpansion>
|
||||
</ProfileAction>
|
||||
<AnalyzeAction
|
||||
buildConfiguration = "Debug">
|
||||
</AnalyzeAction>
|
||||
<ArchiveAction
|
||||
buildConfiguration = "Release"
|
||||
revealArchiveInOrganizer = "YES">
|
||||
</ArchiveAction>
|
||||
</Scheme>
|
||||
@@ -0,0 +1,32 @@
|
||||
{
|
||||
"configurations" : [
|
||||
{
|
||||
"id" : "CF37E70B-D810-4CF2-AB41-571BAFF72572",
|
||||
"name" : "Default",
|
||||
"options" : {
|
||||
|
||||
}
|
||||
},
|
||||
{
|
||||
"id" : "33436295-E24E-439B-9B8E-4602E0A6C8BB",
|
||||
"name" : "TSan",
|
||||
"options" : {
|
||||
"threadSanitizerEnabled" : true
|
||||
}
|
||||
}
|
||||
],
|
||||
"defaultOptions" : {
|
||||
"codeCoverage" : false
|
||||
},
|
||||
"testTargets" : [
|
||||
{
|
||||
"parallelizable" : true,
|
||||
"target" : {
|
||||
"containerPath" : "container:Algorithms.xcodeproj",
|
||||
"identifier" : "7D489E4629CE969D00499B21",
|
||||
"name" : "AlgorithmsTests"
|
||||
}
|
||||
}
|
||||
],
|
||||
"version" : 1
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2023 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
PRODUCT_NAME = AlgorithmsTests
|
||||
PRODUCT_BUNDLE_IDENTIFIER = org.swift.AlgorithmsTests
|
||||
|
||||
SUPPORTED_PLATFORMS = macosx iphoneos iphonesimulator watchos watchsimulator appletvos appletvsimulator
|
||||
ARCHS = $(ARCHS_STANDARD)
|
||||
|
||||
CURRENT_PROJECT_VERSION = 1
|
||||
MARKETING_VERSION = 1.0
|
||||
|
||||
GENERATE_INFOPLIST_FILE = YES
|
||||
|
||||
ENABLE_TESTABILITY = NO
|
||||
@@ -0,0 +1,5 @@
|
||||
# Xcode build files
|
||||
|
||||
The project file here can be used to build a variant of this package with Xcode, producing a single framework bundle. Build settings are entirely configured via the provided xcconfig files.
|
||||
|
||||
Beware! The contents of this directory are not source stable. They are provided as is, with no compatibility promises across package releases. Future versions of this package can arbitrarily change these files or remove them, without any advance notice. (This can include patch releases.)
|
||||
@@ -0,0 +1,88 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2023 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
SDKROOT = macosx
|
||||
|
||||
CODE_SIGN_STYLE = Automatic
|
||||
CODE_SIGN_IDENTITY = -
|
||||
CODE_SIGN_IDENTITY[sdk=iphoneos*] = "iOS Developer"
|
||||
CODE_SIGN_IDENTITY[sdk=watchos*] = "iOS Developer"
|
||||
CODE_SIGN_IDENTITY[sdk=appletvos*] = "iOS Developer"
|
||||
|
||||
SWIFT_VERSION = 5.5
|
||||
ONLY_ACTIVE_ARCH[config=Debug] = YES
|
||||
|
||||
SWIFT_ACTIVE_COMPILATION_CONDITIONS = $(inherited) ALGORITHMS_DARWIN_ONLY
|
||||
|
||||
SWIFT_COMPILATION_MODE[config=Release] = wholemodule
|
||||
SWIFT_COMPILATION_MODE[config=Debug] = singlefile
|
||||
|
||||
SWIFT_OPTIMIZATION_LEVEL[config=Release] = -O
|
||||
SWIFT_OPTIMIZATION_LEVEL[config=Debug] = -Onone
|
||||
|
||||
SWIFT_EMIT_LOC_STRINGS = NO
|
||||
SWIFT_INSTALL_OBJC_HEADER = NO
|
||||
|
||||
COPY_PHASE_STRIP = NO
|
||||
|
||||
DEBUG_INFORMATION_FORMAT[config=Release] = dwarf-with-dsym
|
||||
DEBUG_INFORMATION_FORMAT[config=Debug] = dwarf
|
||||
|
||||
ALWAYS_SEARCH_USER_PATHS = NO
|
||||
|
||||
ENABLE_TESTABILITY = NO
|
||||
ENABLE_USER_SCRIPT_SANDBOXING = YES
|
||||
DEAD_CODE_STRIPPING = YES
|
||||
|
||||
GCC_DYNAMIC_NO_PIC = NO
|
||||
GCC_NO_COMMON_BLOCKS = YES
|
||||
GCC_OPTIMIZATION_LEVEL[config=Debug] = 0
|
||||
|
||||
GCC_C_LANGUAGE_STANDARD = gnu11
|
||||
CLANG_CXX_LANGUAGE_STANDARD = gnu++20
|
||||
CLANG_ENABLE_MODULES = YES
|
||||
CLANG_ENABLE_OBJC_ARC = YES
|
||||
CLANG_ENABLE_OBJC_WEAK = YES
|
||||
ENABLE_NS_ASSERTIONS[config=Release] = NO
|
||||
ENABLE_STRICT_OBJC_MSGSEND = YES
|
||||
GCC_PREPROCESSOR_DEFINITIONS[config=Release] = DEBUG=1 $(inherited)
|
||||
|
||||
CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES
|
||||
CLANG_WARN_BOOL_CONVERSION = YES
|
||||
CLANG_WARN_COMMA = YES
|
||||
CLANG_WARN_CONSTANT_CONVERSION = YES
|
||||
CLANG_WARN_DOCUMENTATION_COMMENTS = YES
|
||||
CLANG_WARN_EMPTY_BODY = YES
|
||||
CLANG_WARN_ENUM_CONVERSION = YES
|
||||
CLANG_WARN_INFINITE_RECURSION = YES
|
||||
CLANG_WARN_INT_CONVERSION = YES
|
||||
CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES
|
||||
CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES
|
||||
CLANG_WARN_STRICT_PROTOTYPES = YES
|
||||
CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE
|
||||
CLANG_WARN_UNREACHABLE_CODE = YES
|
||||
|
||||
GCC_WARN_64_TO_32_BIT_CONVERSION = YES
|
||||
GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR
|
||||
GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE
|
||||
GCC_WARN_UNUSED_FUNCTION = YES
|
||||
GCC_WARN_UNUSED_VARIABLE = YES
|
||||
CLANG_WARN_RANGE_LOOP_ANALYSIS = YES
|
||||
CLANG_WARN_SUSPICIOUS_MOVE = YES
|
||||
CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES
|
||||
CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR
|
||||
CLANG_WARN_OBJC_LITERAL_CONVERSION = YES
|
||||
CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR
|
||||
CLANG_WARN__DUPLICATE_METHOD_MATCH = YES
|
||||
GCC_WARN_UNDECLARED_SELECTOR = YES
|
||||
CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES
|
||||
CLANG_ANALYZER_NONNULL = YES
|
||||
CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE
|
||||
Reference in new issue
Block a user