Merge branch 'master' into Lenstra-elliptic-curve

Author: oscardssmith

.github/workflows/TagBot.yml

@@ -0,0 +1,11 @@
+name: TagBot
+on:
+  schedule:
+    - cron: 0 * * * *
+jobs:
+  TagBot:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: JuliaRegistries/TagBot@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}

Project.toml

@@ -1,16 +1,18 @@
 name = "Primes"
 uuid = "27ebfcd6-29c5-5fa9-bf4b-fb8fc14df3ae"
-version = "0.5.1"
+version = "0.5.2"
+
+[deps]
+IntegerMathUtils = "18e54dd8-cb9d-406c-a71d-865a43cbb235"
 
 [extras]
-DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 IntegerMathUtils = "18e54dd8-cb9d-406c-a71d-865a43cbb235"
+DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
 test = ["DataStructures", "IntegerMathUtils", "Test"]
 
 [compat]
-DataStructures = "0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17"
 IntegerMathUtils = "0.1"
 julia = "1"

src/Primes.jl

@@ -252,19 +252,19 @@ function factor!(n::T, h::AbstractDict{K,Int}) where {T<:Integer,K<:Integer}
     end
 
     local p::T
-    nsqrt = isqrt(n)
     for p in PRIMES
-        p > nsqrt && break
-        if n % p == 0
-            while true
-                h[p] = get(h, p, 0) + 1
-                n, r = divrem(n, p)
-                r != 0 && break
-            end
-            n == 1 && return h
-            nsqrt = isqrt(n)
+        num_p = 0
+        while true
+            q, r = divrem(n, T(p)) # T(p) so julia <1.9 uses fast divrem for `BigInt`
+            r == 0 || break
+            num_p += 1
+            n = q
         end
+        # h[p] += num_p (about 2x faster, but the speed only matters for small numbers)
+        num_p > 0 && increment!(h, num_p, p)
+        p*p > n && break
     end
+    n == 1 && return h
     isprime(n) && (h[n]=1; return h)
     lenstrafactors!(widen(n), h)
 end
@@ -417,7 +417,7 @@ function lenstrafactors!(n::T, h::AbstractDict{K,Int}) where{T<:Integer,K<:Integ
             end
         end
     end
-    throw(ArgumentError("This number is too big to be factored with this algorith effectively"))
+    throw(ArgumentError("This number is too big to be factored with this algorithm effectively"))
 end
 
 function lenstra_get_factor(N::T, a, small_primes, plimit) where T <: Integer

src/factorization.jl

@@ -4,7 +4,12 @@
 struct Factorization{T<:Integer} <: AbstractDict{T, Int}
     pe::Vector{Pair{T, Int}} # Prime-Exponent
 
-    Factorization{T}() where {T<:Integer} = new{T}(Vector{Pair{T, Int}}())
+    function Factorization{T}() where {T<:Integer}
+        # preallocates enough space that numbers smaller than 2310 won't need to resize
+        v = Vector{Pair{T, Int}}(undef, 4)
+        empty!(v)
+        new{T}(v)
+    end
 end
 
 function Factorization{T}(d::AbstractDict) where T<:Integer
@@ -19,23 +24,39 @@ Base.convert(::Type{Factorization}, d::AbstractDict) = Factorization(d)
 Base.iterate(f::Factorization, state...) = iterate(f.pe, state...)
 
 function Base.get(f::Factorization, p, default)
-    found = searchsorted(f.pe, p, by=first)
-    isempty(found) ?
-        default :
-        last(f.pe[first(found)])
+    found = searchsortedfirst(f.pe, p, by=first)
+    (found > length(f.pe) || first(f.pe[found])) != p  ? default : last(f.pe[found])
 end
 
 Base.getindex(f::Factorization, p::Integer) = get(f, p, 0)
 
 function Base.setindex!(f::Factorization{T}, e::Int, p::Integer) where T
-    found = searchsorted(f.pe, p, by=first)
-    if isempty(found)
-        insert!(f.pe, first(found), T(p)=>e)
+    found = searchsortedfirst(f.pe, p, by=first)
+    if found > length(f.pe)
+        push!(f.pe, T(p)=>e)
+    elseif first(f.pe[found]) != p
+        insert!(f.pe, found, T(p)=>e)
+    else
+        f.pe[found] = T(p)=>e
+    end
+    f
+end
+
+"""
+    impliments f[p] += e faster
+"""
+function increment!(f::Factorization{T}, e::Int, p::Integer) where T
+    found = searchsortedfirst(f.pe, p, by=first)
+    if found > length(f.pe)
+        push!(f.pe, T(p)=>e)
+    elseif first(f.pe[found]) != p
+        insert!(f.pe, found, T(p)=>e)
     else
-        f.pe[first(found)] = T(p)=>e
+        f.pe[found] = T(p)=>(last(f.pe[found])+e)
     end
     f
 end
+increment!(f::AbstractDict, e::Int, p::Integer) = (f[p] = get(f, p, 0) + e)
 
 Base.length(f::Factorization) = length(f.pe)
 

test/runtests.jl

@@ -261,7 +261,7 @@ for T = (Int, UInt, BigInt)
     @test f == d == Dict(f) == Factorization(d) == convert(Factorization, d)
     @test collect(f) == sort!(collect(d)) # test start/next/done
     @test length(f) == length(d)
-    @test get(f, T(101), nothing) == nothing
+    @test get(f, T(101), nothing) === nothing
     @test f[101] == 0
     @test f[0] == 0
     f[0] = 1