faster permutations, based on what rdeits suggested

src/permutations.jl

@@ -9,14 +9,52 @@ export
     permutations
 
 
-struct Permutations{T}
-    a::T
-    t::Int
+struct PermutationIterator{T}
+    data::T
+    length::Int
+end
+
+function has_repeats(state::Vector{Int})
+    for outer in 1:length(state)
+        for inner in (outer+1):length(state)
+            if state[outer] == state[inner]
+                return true
+            end
+        end
+    end
+    return false
+end
+
+function increment!(state::Vector{Int}, max::Int)
+    state[end] += 1
+    for i in length(state):-1:2
+        if state[i] > max
+            state[i] = 1
+            state[i-1] += 1
+        end
+    end
+end
+
+function next_permutation!(state::Vector{Int}, max::Int)
+    while true
+        increment!(state, max)
+        if !has_repeats(state)
+            break
+        end
+    end
+end
+
+function Base.iterate(p::PermutationIterator, state::Vector{Int}=ones(Int, p.length))
+    next_permutation!(state, length(p.data))
+    if state[1] > length(p.data)
+        return nothing
+    end
+    [p.data[i] for i in state], state
 end
 
-Base.eltype(::Type{Permutations{T}}) where {T} = Vector{eltype(T)}
+Base.length(p::PermutationIterator) = Int(div(factorial(big(length(p.data))), factorial(big(length(p.data) - p.length))))
+Base.eltype(p::PermutationIterator) = Vector{eltype(p.data)}
 
-Base.length(p::Permutations) = (0 <= p.t <= length(p.a)) ? factorial(length(p.a), length(p.a)-p.t) : 0
 
 """
     permutations(a)
@@ -25,51 +63,64 @@ Generate all permutations of an indexable object `a` in lexicographic order. Bec
 can be very large, this function returns an iterator object.
 Use `collect(permutations(a))` to get an array of all permutations.
 """
-permutations(a) = Permutations(a, length(a))
+permutations(a) = permutations(a, length(a))
+
+"Need special case for strings because we require 1-based indexing, and there is no `size(::String)`"
+permutations(a::AbstractString) = permutations(collect(a), length(a))
+
+"Need special case for strings because we require 1-based indexing, and there is no `size(::String)`"
+permutations(a::AbstractString, t::Integer) = permutations(collect(a), t)
 
 """
     permutations(a, t)
 
 Generate all size `t` permutations of an indexable object `a`.
 """
 function permutations(a, t::Integer)
+    Base.require_one_based_indexing(a)
     if t < 0
-        t = length(a) + 1
+        return []
+    elseif t > length(a)
+        return []
+    elseif t == 0
+        return [Vector{eltype(a)}()]
     end
-    Permutations(a, t)
+    PermutationIterator(a, t)
 end
 
-function Base.iterate(p::Permutations, s = collect(1:length(p.a)))
-    (!isempty(s) && max(s[1], p.t) > length(p.a) || (isempty(s) && p.t > 0)) && return
-    nextpermutation(p.a, p.t ,s)
-end
 
 function nextpermutation(m, t, state)
     perm = [m[state[i]] for i in 1:t]
     n = length(state)
     if t <= 0
-        return(perm, [n+1])
+        return (perm, [n + 1])
     end
     s = copy(state)
     if t < n
         j = t + 1
-        while j <= n &&  s[t] >= s[j]; j+=1; end
+        while j <= n && s[t] >= s[j]
+            j += 1
+        end
     end
     if t < n && j <= n
         s[t], s[j] = s[j], s[t]
     else
         if t < n
-            reverse!(s, t+1)
+            reverse!(s, t + 1)
         end
         i = t - 1
-        while i>=1 && s[i] >= s[i+1]; i -= 1; end
+        while i >= 1 && s[i] >= s[i+1]
+            i -= 1
+        end
         if i > 0
             j = n
-            while j>i && s[i] >= s[j]; j -= 1; end
+            while j > i && s[i] >= s[j]
+                j -= 1
+            end
             s[i], s[j] = s[j], s[i]
-            reverse!(s, i+1)
+            reverse!(s, i + 1)
         else
-            s[1] = n+1
+            s[1] = n + 1
         end
     end
     return (perm, s)
@@ -94,18 +145,18 @@ function Base.length(c::MultiSetPermutations)
     else
         g = [factorial(i) for i in 0:t]
     end
-    p = [g[t+1]; zeros(Float64,t)]
+    p = [g[t+1]; zeros(Float64, t)]
     for i in 1:length(c.f)
         f = c.f[i]
         if i == 1
             for j in 1:min(f, t)
-                p[j+1] = g[t+1]/g[j+1]
+                p[j+1] = g[t+1] / g[j+1]
             end
         else
             for j in t:-1:1
                 q = 0
-                for k in (j+1):-1:max(1,j+1-f)
-                    q += p[k]/g[j+2-k]
+                for k in (j+1):-1:max(1, j + 1 - f)
+                    q += p[k] / g[j+2-k]
                 end
                 p[j+1] = q
             end
@@ -134,7 +185,7 @@ function multiset_permutations(m, f::Vector{<:Integer}, t::Integer)
     MultiSetPermutations(m, f, t, ref)
 end
 
-function Base.iterate(p::MultiSetPermutations, s = p.ref)
+function Base.iterate(p::MultiSetPermutations, s=p.ref)
     (!isempty(s) && max(s[1], p.t) > length(p.ref) || (isempty(s) && p.t > 0)) && return
     nextpermutation(p.m, p.t, s)
 end
@@ -151,7 +202,7 @@ function nthperm!(a::AbstractVector, k::Integer)
     f = factorial(oftype(k, n))
     0 < k <= f || throw(ArgumentError("permutation k must satisfy 0 < k ≤ $f, got $k"))
     k -= 1 # make k 1-indexed
-    for i=1:n-1
+    for i = 1:n-1
         f ÷= n - i + 1
         j = k ÷ f
         k -= j * f
@@ -182,7 +233,7 @@ function nthperm(p::AbstractVector{<:Integer})
     isperm(p) || throw(ArgumentError("argument is not a permutation"))
     k, n = 1, length(p)
     for i = 1:n-1
-        f = factorial(n-i)
+        f = factorial(n - i)
         for j = i+1:n
             k += ifelse(p[j] < p[i], f, 0)
         end
@@ -193,9 +244,9 @@ end
 
 # Parity of permutations
 
-const levicivita_lut = cat([0 0  0;  0 0 1; 0 -1 0],
-                           [0 0 -1;  0 0 0; 1  0 0],
-                           [0 1  0; -1 0 0; 0  0 0]; dims=3)
+const levicivita_lut = cat([0 0 0; 0 0 1; 0 -1 0],
+    [0 0 -1; 0 0 0; 1 0 0],
+    [0 1 0; -1 0 0; 0 0 0]; dims=3)
 
 """
     levicivita(p)

test/combinations.jl

@@ -1,43 +1,46 @@
-@test [combinations([])...] == []
-@test [combinations(['a', 'b', 'c'])...] == [['a'],['b'],['c'],['a','b'],['a','c'],['b','c'],['a','b','c']]
-
-@test [combinations("abc",3)...] == [['a','b','c']]
-@test [combinations("abc",2)...] == [['a','b'],['a','c'],['b','c']]
-@test [combinations("abc",1)...] == [['a'],['b'],['c']]
-@test [combinations("abc",0)...] == [[]]
-@test [combinations("abc",-1)...] == []
-
-@test filter(x->iseven(x[1]),[combinations([1,2,3],2)...]) == Any[[2,3]]
-
-# multiset_combinations
-@test [multiset_combinations("aabc", 5)...] == Any[]
-@test [multiset_combinations("aabc", 2)...] == Any[['a','a'],['a','b'],['a','c'],['b','c']]
-@test [multiset_combinations("aabc", 1)...] == Any[['a'],['b'],['c']]
-@test [multiset_combinations("aabc", 0)...] == Any[Char[]]
-@test [multiset_combinations("aabc", -1)...] == Any[]
-@test [multiset_combinations("", 1)...] == Any[]
-@test [multiset_combinations("", 0)...] == Any[Char[]]
-@test [multiset_combinations("", -1)...] == Any[]
-
-# with_replacement_combinations
-@test [with_replacement_combinations("abc", 2)...] == Any[['a','a'],['a','b'],['a','c'],
-                                                              ['b','b'],['b','c'],['c','c']]
-@test [with_replacement_combinations("abc", 1)...] == Any[['a'],['b'],['c']]
-@test [with_replacement_combinations("abc", 0)...] == Any[Char[]]
-@test [with_replacement_combinations("abc", -1)...] == Any[]
-@test [with_replacement_combinations("", 1)...] == Any[]
-@test [with_replacement_combinations("", 0)...] == Any[Char[]]
-@test [with_replacement_combinations("", -1)...] == Any[]
-
-
-#cool-lex iterator
-@test_throws DomainError [CoolLexCombinations(-1, 1)...]
-@test_throws DomainError [CoolLexCombinations(5, 0)...]
-@test [CoolLexCombinations(4,2)...] == Vector[[1,2], [2,3], [1,3], [2,4], [3,4], [1,4]]
-@test isa(iterate(CoolLexCombinations(1000, 20))[2], Combinatorics.CoolLexIterState{BigInt})
-
-# Power set
-@test collect(powerset([])) == Any[[]]
-@test collect(powerset(['a', 'b', 'c'])) == Any[[],['a'],['b'],['c'],['a','b'],['a','c'],['b','c'],['a','b','c']]
-@test collect(powerset(['a', 'b', 'c'], 1)) == Any[['a'],['b'],['c'],['a','b'],['a','c'],['b','c'],['a','b','c']]
-@test collect(powerset(['a', 'b', 'c'], 1, 2)) == Any[['a'],['b'],['c'],['a','b'],['a','c'],['b','c']]
+@testset "combinations" begin
+    @test [combinations([])...] == []
+    @test [combinations(['a', 'b', 'c'])...] == [['a'], ['b'], ['c'], ['a', 'b'], ['a', 'c'], ['b', 'c'], ['a', 'b', 'c']]
+
+    @test [combinations("abc", 3)...] == [['a', 'b', 'c']]
+    @test [combinations("abc", 2)...] == [['a', 'b'], ['a', 'c'], ['b', 'c']]
+    @test [combinations("abc", 1)...] == [['a'], ['b'], ['c']]
+    @test [combinations("abc", 0)...] == [[]]
+    @test [combinations("abc", -1)...] == []
+
+    @test filter(x -> iseven(x[1]), [combinations([1, 2, 3], 2)...]) == Any[[2, 3]]
+
+    # multiset_combinations
+    @test [multiset_combinations("aabc", 5)...] == Any[]
+    @test [multiset_combinations("aabc", 2)...] == Any[['a', 'a'], ['a', 'b'], ['a', 'c'], ['b', 'c']]
+    @test [multiset_combinations("aabc", 1)...] == Any[['a'], ['b'], ['c']]
+    @test [multiset_combinations("aabc", 0)...] == Any[Char[]]
+    @test [multiset_combinations("aabc", -1)...] == Any[]
+    @test [multiset_combinations("", 1)...] == Any[]
+    @test [multiset_combinations("", 0)...] == Any[Char[]]
+    @test [multiset_combinations("", -1)...] == Any[]
+
+    # with_replacement_combinations
+    @test [with_replacement_combinations("abc", 2)...] == Any[['a', 'a'], ['a', 'b'], ['a', 'c'],
+        ['b', 'b'], ['b', 'c'], ['c', 'c']]
+    @test [with_replacement_combinations("abc", 1)...] == Any[['a'], ['b'], ['c']]
+    @test [with_replacement_combinations("abc", 0)...] == Any[Char[]]
+    @test [with_replacement_combinations("abc", -1)...] == Any[]
+    @test [with_replacement_combinations("", 1)...] == Any[]
+    @test [with_replacement_combinations("", 0)...] == Any[Char[]]
+    @test [with_replacement_combinations("", -1)...] == Any[]
+
+
+    #cool-lex iterator
+    @test_throws DomainError [CoolLexCombinations(-1, 1)...]
+    @test_throws DomainError [CoolLexCombinations(5, 0)...]
+    @test [CoolLexCombinations(4, 2)...] == Vector[[1, 2], [2, 3], [1, 3], [2, 4], [3, 4], [1, 4]]
+    @test isa(iterate(CoolLexCombinations(1000, 20))[2], Combinatorics.CoolLexIterState{BigInt})
+
+    # Power set
+    @test collect(powerset([])) == Any[[]]
+    @test collect(powerset(['a', 'b', 'c'])) == Any[[], ['a'], ['b'], ['c'], ['a', 'b'], ['a', 'c'], ['b', 'c'], ['a', 'b', 'c']]
+    @test collect(powerset(['a', 'b', 'c'], 1)) == Any[['a'], ['b'], ['c'], ['a', 'b'], ['a', 'c'], ['b', 'c'], ['a', 'b', 'c']]
+    @test collect(powerset(['a', 'b', 'c'], 1, 2)) == Any[['a'], ['b'], ['c'], ['a', 'b'], ['a', 'c'], ['b', 'c']]
+
+end

test/factorials.jl

@@ -1,38 +1,41 @@
-@test factorial(7,3) == 7*6*5*4
-@test_throws DomainError factorial(3,7)
-@test_throws DomainError factorial(-3,-7)
-@test_throws DomainError factorial(-7,-3)
-#JuliaLang/julia#9943
-@test factorial(big(100), (80)) == 1303995018204712451095685346159820800000
-#JuliaLang/julia#9950
-@test_throws OverflowError factorial(1000,80)
-
-# derangement
-@test derangement(4) == subfactorial(4) == 9
-@test derangement(24) == parse(BigInt,"228250211305338670494289")
-
-# partialderangement
-@test partialderangement(7, 3) == 315
-@test_throws DomainError partialderangement(8, 9)
-@test_throws DomainError partialderangement(-8, 0)
-
-# doublefactorial
-@test doublefactorial(70) == parse(BigInt,"355044260642859198243475901411974413130137600000000")
-@test_throws DomainError doublefactorial(-1)
-
-# hyperfactorial
-@test hyperfactorial(8) == parse(BigInt,"55696437941726556979200000")
-@test hyperfactorial(0) == parse(BigInt,"1")
-@test hyperfactorial(1) == parse(BigInt,"1")
-@test hyperfactorial(2) == parse(BigInt,"4")
-
-# multifactorial
-@test multifactorial(40,2) == doublefactorial(40)
-@test_throws DomainError multifactorial(-1,1)
-
-# multinomial
-@test multinomial(1,4,4,2) == 34650
-
-# primorial
-@test primorial(17) == 510510
-@test_throws DomainError primorial(-1)
+@testset "factorials" begin
+    @test factorial(7, 3) == 7 * 6 * 5 * 4
+    @test_throws DomainError factorial(3, 7)
+    @test_throws DomainError factorial(-3, -7)
+    @test_throws DomainError factorial(-7, -3)
+    #JuliaLang/julia#9943
+    @test factorial(big(100), (80)) == 1303995018204712451095685346159820800000
+    #JuliaLang/julia#9950
+    @test_throws OverflowError factorial(1000, 80)
+
+    # derangement
+    @test derangement(4) == subfactorial(4) == 9
+    @test derangement(24) == parse(BigInt, "228250211305338670494289")
+
+    # partialderangement
+    @test partialderangement(7, 3) == 315
+    @test_throws DomainError partialderangement(8, 9)
+    @test_throws DomainError partialderangement(-8, 0)
+
+    # doublefactorial
+    @test doublefactorial(70) == parse(BigInt, "355044260642859198243475901411974413130137600000000")
+    @test_throws DomainError doublefactorial(-1)
+
+    # hyperfactorial
+    @test hyperfactorial(8) == parse(BigInt, "55696437941726556979200000")
+    @test hyperfactorial(0) == parse(BigInt, "1")
+    @test hyperfactorial(1) == parse(BigInt, "1")
+    @test hyperfactorial(2) == parse(BigInt, "4")
+
+    # multifactorial
+    @test multifactorial(40, 2) == doublefactorial(40)
+    @test_throws DomainError multifactorial(-1, 1)
+
+    # multinomial
+    @test multinomial(1, 4, 4, 2) == 34650
+
+    # primorial
+    @test primorial(17) == 510510
+    @test_throws DomainError primorial(-1)
+
+end