Extend sign to Factorization. Improve divisors

Implement `sign(::Factorization)` to easily check if the number
represented by a Factorization is lt, gt, or eq to 0, and use it when
identifying special cases in `divisors` and `totient`.

In the `divisors` function:
- No more wasteful allocations from pointlessly `collect`ing factors.
- Make `divisors(0)` return an empty vector instead of throwing.
- Remove unnecessary type annotations and let return types be inferred.

Author: adrsm108

src/Primes.jl

@@ -1,7 +1,7 @@
 # This file includes code that was formerly a part of Julia. License is MIT: http://julialang.org/license
 module Primes
 
-using Base.Iterators: repeated
+using Base.Iterators: repeated, rest
 
 import Base: iterate, eltype, IteratorSize, IteratorEltype
 using Base: BitSigned
@@ -591,7 +591,7 @@ given by `f`. This method may be preferable to [`totient(::Integer)`](@ref)
 when the factorization can be reused for other purposes.
 """
 function totient(f::Factorization{T}) where T <: Integer
-    if !isempty(f) && first(first(f)) == 0
+    if iszero(sign(f))
         throw(ArgumentError("ϕ(0) is not defined"))
     end
     result = one(T)
@@ -908,7 +908,7 @@ prevprimes(start::T, n::Integer) where {T<:Integer} =
     collect(T, Iterators.take(prevprimes(start), n))
 
 """
-    divisors(n::T) -> Vector{T}
+    divisors(n::Integer) -> Vector
 
 Return a vector with the positive divisors of `n`.
 
@@ -918,6 +918,8 @@ lexicographic (rather than numerical) order.
 
 `divisors(-n)` is equivalent to `divisors(n)`.
 
+For convenience, `divisors(0)` returns `[]`.
+
 # Example
 
 ```jldoctest
@@ -935,46 +937,49 @@ julia> divisors(60)
  15         # 5 * 3
  30         # 5 * 3 * 2
  60         # 5 * 3 * 2 * 2
+
+julia> divisors(-10)
+4-element Vector{Int64}:
+  1
+  2
+  5
+ 10
+
+julia> divisors(0)
+Int64[]
 ```
 """
-function divisors(n::T)::Vector{T} where {T<:Integer}
-    n::T = abs(n)
+function divisors(n::T) where {T<:Integer}
+    n = abs(n)
     if iszero(n)
-        throw(ArgumentError("divisors function is not defined for 0"))
+        return T[]
     elseif isone(n)
-        return T[n]
+        return [n]
     else
         return divisors(factor(n))
     end
 end
 
 """
-    divisors(f::Factorization{T}) -> Vector{T}
+    divisors(f::Factorization) -> Vector
 
 Return a vector with the positive divisors of the number whose factorization is `f`. 
 Divisors are sorted lexicographically, rather than numerically.
 """
-function divisors(f::Factorization{T})::Vector{T} where {T<:Integer}
-    factors = collect(f)
-
-    if isempty(factors) # n == 1
-        return T[one(T)] 
-    elseif iszero(first(first(factors))) # n == 0
-        throw(ArgumentError("divisors function is not defined for 0"))
-    elseif first(first(factors)) == -1 # n < 0
-        if length(factors) == 1 # n == -1
-            return T[one(T)]
-        else
-            deleteat!(factors, 1)
-        end
+function divisors(f::Factorization{T}) where {T<:Integer}
+    sgn = sign(f)
+    if iszero(sgn) # n == 0
+        return T[]
+    elseif isempty(f) || length(f) == 1 && sgn < 0 # n == 1 or n == -1
+        return [one(T)]
     end
 
-    i::Int = 1
-    m::Int = 1
-    divs = Vector{T}(undef, prod(x -> x.second + 1, factors))
+    i = m = 1
+    fs = rest(f, 1 + (sgn < 0))
+    divs = Vector{T}(undef, prod(x -> x.second + 1, fs))
     divs[i] = one(T)
 
-    for (p, k) in factors
+    for (p, k) in fs
         i = 1
         for _ in 1:k
             for j in i:(i+m-1)

src/factorization.jl

@@ -65,3 +65,5 @@ Base.length(f::Factorization) = length(f.pe)
 
 Base.show(io::IO, ::MIME{Symbol("text/plain")}, f::Factorization) =
     join(io, isempty(f) ? "1" : [(e == 1 ? "$p" : "$p^$e") for (p,e) in f.pe], " * ")
+
+Base.sign(f::Factorization) = isempty(f.pe) ? one(keytype(f)) : sign(first(f.pe[1]))

test/runtests.jl

@@ -236,6 +236,13 @@ end
 
 @test factor(1) == Dict{Int,Int}()
 
+# correctly return sign of factored numbers
+@test sign(factor(100)) == 1
+@test sign(factor(1)) == 1
+@test sign(factor(0)) == 0
+@test sign(factor(-1)) == -1
+@test sign(factor(-100)) == -1
+
 # factor returns a sorted dict
 @test all([issorted(collect(factor(rand(Int)))) for x in 1:100])
 
@@ -319,7 +326,7 @@ divisors_brute_force(n) = [d for d in one(n):n if iszero(n % d)]
 @testset "divisors(::$T)" for T in [Int16, Int32, Int64, BigInt]
     # 1 and 0 are handled specially
     @test divisors(one(T)) == divisors(-one(T)) == T[one(T)]
-    @test_throws ArgumentError @inferred(divisors(T(0)))
+    @test divisors(zero(T)) == T[]
 
     for n in 2:1000
         ds = divisors(T(n))
@@ -333,7 +340,7 @@ end
     # We just need to verify that the following cases are also handled correctly:
     @test divisors(factor(1)) == divisors(factor(-1)) == [1] # factorizations of 1 and -1
     @test divisors(factor(-56)) == divisors(factor(56)) == [1, 2, 4, 8, 7, 14, 28, 56] # factorizations of negative numbers
-    @test_throws ArgumentError @inferred(divisors(factor(0))) # factorizations of 0
+    @test isempty(divisors(factor(0)))
 end
 
 # check copy property for big primes relied upon in nextprime/prevprime