mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
119 lines
2.6 KiB
Swift
119 lines
2.6 KiB
Swift
// RUN: %target-run-simple-swift | FileCheck %s
|
|
|
|
// Generate all possible permutes.
|
|
func _permuteInternal(
|
|
elem: Int, _ size : Int,
|
|
inout _ perm : [Int], inout _ visited : [Bool],
|
|
_ verify : ([Int]) -> ()
|
|
) {
|
|
if (elem == size) {
|
|
verify(perm)
|
|
return
|
|
}
|
|
|
|
for i in 0..<size {
|
|
if (visited[i]) {
|
|
continue
|
|
}
|
|
visited[i] = true
|
|
perm[elem] = i
|
|
_permuteInternal(elem + 1, size, &perm, &visited, verify)
|
|
visited[i] = false
|
|
}
|
|
}
|
|
|
|
// Convenience wrapper for the permute method.
|
|
func permute(size : Int, _ verify : ([Int]) -> ()) {
|
|
var perm = [Int](count: size, repeatedValue: 0)
|
|
var visited = [Bool](count: size, repeatedValue: false)
|
|
_permuteInternal(0, size, &perm, &visited, verify)
|
|
}
|
|
|
|
|
|
// A simple random number generator.
|
|
func randomize(size : Int, _ verify : ([Int]) -> ()) {
|
|
var arr : [Int] = []
|
|
var N = 1
|
|
var M = 1
|
|
for i in 0..<size {
|
|
N = N * 19 % 1024
|
|
M = (N + M) % size
|
|
arr.append(N)
|
|
if (M % 3 == 0) {
|
|
arr.append(M)
|
|
}
|
|
}
|
|
verify(arr)
|
|
}
|
|
|
|
// Verify the permute method itself:
|
|
let printer : ([Int]) -> () = {
|
|
println($0)
|
|
}
|
|
//CHECK: [0, 1, 2]
|
|
//CHECK: [0, 2, 1]
|
|
//CHECK: [1, 0, 2]
|
|
//CHECK: [1, 2, 0]
|
|
//CHECK: [2, 0, 1]
|
|
//CHECK: [2, 1, 0]
|
|
permute(3, printer)
|
|
|
|
// Now, let's verify the sort.
|
|
let sort_verifier : ([Int]) -> () = {
|
|
var y = sorted($0)
|
|
for i in 0..<y.count() - 1 {
|
|
if (y[i] > y[i+1]) {
|
|
println("Error: \(y)")
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
//CHECK-NOT: Error!
|
|
permute(2, sort_verifier)
|
|
permute(6, sort_verifier)
|
|
permute(7, sort_verifier)
|
|
//CHECK: Test1 - Done
|
|
println("Test1 - Done")
|
|
|
|
// Now, let's verify the sort.
|
|
let partition_verifier : ([Int]) -> () = {
|
|
var y = $0
|
|
// Partition() returns the index to the pivot value.
|
|
let idx = partition(&y, 0..<y.count())
|
|
// Check that all of the elements in the first partition are smaller or
|
|
// equal to the pivot value.
|
|
for i in 0..<idx {
|
|
if y[i] > y[idx] {
|
|
print("Error!\n")
|
|
return
|
|
}
|
|
}
|
|
// Check that all of the elements in the second partition are greater or
|
|
// equal to the pivot value.
|
|
for i in idx..<y.count() - 1 {
|
|
if y[i] < y[idx] {
|
|
print("Error!\n")
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// FIXME(prext): remove partition() together with the function when
|
|
// protocol extensions land. These tests have been migrated to the new API.
|
|
permute(2, partition_verifier)
|
|
permute(6, partition_verifier)
|
|
permute(7, partition_verifier)
|
|
//CHECK-NOT: Error!
|
|
//CHECK: Test2 - Done
|
|
println("Test2 - Done")
|
|
|
|
|
|
randomize(70, sort_verifier)
|
|
randomize(700, sort_verifier)
|
|
randomize(1900, sort_verifier)
|
|
//CHECK-NOT: Error!
|
|
//CHECK: Test3 - Done
|
|
println("Test3 - Done")
|
|
|