diff --git a/NEWS.md b/NEWS.md index 2b924408a5636..5d6e48b217c7d 100644 --- a/NEWS.md +++ b/NEWS.md @@ -90,7 +90,7 @@ Breaking changes Library improvements -------------------- - * Most of the combinatorics functions have been moved from `Base` + * Most of the combinatorics functions have been moved from `Base` to the [Combinatorics.jl package](https://github.com/JuliaLang/Combinatorics.jl) ([#13897]). * Packages: @@ -173,6 +173,9 @@ Library improvements or `is_apple()`. There's now also an `@static` macro that will evaluate the condition of an if-statement at compile time, for when a static branch is required ([#16219]). + * Prime number related functions have been moved from `Base` to the + [Primes.jl package](https://github.com/JuliaMath/Primes.jl) ([#16481]). + Deprecated or removed --------------------- diff --git a/base/deprecated.jl b/base/deprecated.jl index 142f5d6a57c54..fded63de1402e 100644 --- a/base/deprecated.jl +++ b/base/deprecated.jl @@ -934,6 +934,16 @@ for deprecatedfunc in [:combinations, :factorial, :prevprod, :levicivita, end end +# Primes functions that have been moved out of base (#16481) +for deprecatedfunc in [:isprime, :primes, :primesmask, :factor] + @eval begin + $deprecatedfunc(args...) = error(string($deprecatedfunc, args, + " has been moved to the package Primes.jl.\n", + "Run Pkg.add(\"Primes\") to install Primes on Julia v0.5-")) + export $deprecatedfunc + end +end + #14335 @deprecate super(T::DataType) supertype(T) diff --git a/base/docs/helpdb/Base.jl b/base/docs/helpdb/Base.jl index 192885623dbb3..54516e9a4f685 100644 --- a/base/docs/helpdb/Base.jl +++ b/base/docs/helpdb/Base.jl @@ -1291,21 +1291,6 @@ is equivalent to `!isapprox(x,y)`. """ isapprox -""" - primes([lo,] hi) - -Returns a collection of the prime numbers (from `lo`, if specified) up to `hi`. -""" -primes - -""" - primesmask([lo,] hi) - -Returns a prime sieve, as a `BitArray`, of the positive integers (from `lo`, if specified) -up to `hi`. Useful when working with either primes or composite numbers. -""" -primesmask - """ sinh(x) @@ -7719,23 +7704,6 @@ the same as the way an object is printed in the Julia REPL.) """ TextDisplay -""" - factor(n) -> Dict - -Compute the prime factorization of an integer `n`. Returns a dictionary. The keys of the -dictionary correspond to the factors, and hence are of the same type as `n`. The value -associated with each key indicates the number of times the factor appears in the -factorization. - -```jldoctest -julia> factor(100) # == 2*2*5*5 -Dict{Int64,Int64} with 2 entries: - 2 => 2 - 5 => 2 -``` -""" -factor - """ ismatch(r::Regex, s::AbstractString) -> Bool @@ -8391,32 +8359,6 @@ any element type for which `dot` is defined), compute the Euclidean dot product """ vecdot -""" - isprime(x::Integer) -> Bool - -Returns `true` if `x` is prime, and `false` otherwise. - -```jldoctest -julia> isprime(3) -true -``` -""" -isprime(::Integer) - -""" - isprime(x::BigInt, [reps = 25]) -> Bool - -Probabilistic primality test. Returns `true` if `x` is prime; and `false` if `x` is not -prime with high probability. The false positive rate is about `0.25^reps`. `reps = 25` is -considered safe for cryptographic applications (Knuth, Seminumerical Algorithms). - -```jldoctest -julia> isprime(big(3)) -true -``` -""" -isprime(::BigInt, ?) - """ >(x, y) diff --git a/base/exports.jl b/base/exports.jl index e3e54124b3494..162a98484bc56 100644 --- a/base/exports.jl +++ b/base/exports.jl @@ -351,7 +351,6 @@ export exp2, expm1, exponent, - factor, factorial, fld, fld1, @@ -380,7 +379,6 @@ export isnan, isodd, ispow2, - isprime, isqrt, isreal, isimag, @@ -412,8 +410,6 @@ export prevfloat, prevpow, prevpow2, - primes, - primesmask, rad2deg, rationalize, real, diff --git a/base/gmp.jl b/base/gmp.jl index b5edee0436f5a..5c45d53f05ce9 100644 --- a/base/gmp.jl +++ b/base/gmp.jl @@ -6,7 +6,7 @@ export BigInt import Base: *, +, -, /, <, <<, >>, >>>, <=, ==, >, >=, ^, (~), (&), (|), ($), binomial, cmp, convert, div, divrem, factorial, fld, gcd, gcdx, lcm, mod, - ndigits, promote_rule, rem, show, isqrt, string, isprime, powermod, + ndigits, promote_rule, rem, show, isqrt, string, powermod, sum, trailing_zeros, trailing_ones, count_ones, base, tryparse_internal, bin, oct, dec, hex, isequal, invmod, prevpow2, nextpow2, ndigits0z, widen, signed, unsafe_trunc, trunc @@ -541,8 +541,6 @@ function ndigits0z(x::BigInt, b::Integer=10) end ndigits(x::BigInt, b::Integer=10) = x.size == 0 ? 1 : ndigits0z(x,b) -isprime(x::BigInt, reps=25) = ccall((:__gmpz_probab_prime_p,:libgmp), Cint, (Ptr{BigInt}, Cint), &x, reps) > 0 - prevpow2(x::BigInt) = x.size < 0 ? -prevpow2(-x) : (x <= 2 ? x : one(BigInt) << (ndigits(x, 2)-1)) nextpow2(x::BigInt) = x.size < 0 ? -nextpow2(-x) : (x <= 2 ? x : one(BigInt) << ndigits(x-1, 2)) diff --git a/base/primes.jl b/base/primes.jl deleted file mode 100644 index 52d57d6bc9266..0000000000000 --- a/base/primes.jl +++ /dev/null @@ -1,206 +0,0 @@ -# This file is a part of Julia. License is MIT: http://julialang.org/license - -# Primes generating functions -# https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes -# https://en.wikipedia.org/wiki/Wheel_factorization -# http://primesieve.org -# Jonathan Sorenson, "An analysis of two prime number sieves", Computer Science Technical Report Vol. 1028, 1991 -const wheel = [4, 2, 4, 2, 4, 6, 2, 6] -const wheel_primes = [7, 11, 13, 17, 19, 23, 29, 31] -const wheel_indices = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7] - -@inline wheel_index(n) = ( (d, r) = divrem(n - 1, 30); return 8d + wheel_indices[r+2] ) -@inline wheel_prime(n) = ( (d, r) = ((n - 1) >>> 3, (n - 1) & 7); return 30d + wheel_primes[r+1] ) - -function _primesmask(limit::Int) - limit < 7 && throw(ArgumentError("limit must be at least 7, got $limit")) - n = wheel_index(limit) - m = wheel_prime(n) - sieve = ones(Bool, n) - @inbounds for i = 1:wheel_index(isqrt(limit)) - if sieve[i]; p = wheel_prime(i) - q = p * p - j = (i - 1) & 7 + 1 - while q ≤ m - sieve[wheel_index(q)] = false - q = q + wheel[j] * p - j = j & 7 + 1 - end - end - end - return sieve -end - -function _primesmask(lo::Int, hi::Int) - 7 ≤ lo ≤ hi || throw(ArgumentError("the condition 7 ≤ lo ≤ hi must be met")) - lo == 7 && return _primesmask(hi) - wlo, whi = wheel_index(lo - 1), wheel_index(hi) - m = wheel_prime(whi) - sieve = ones(Bool, whi - wlo) - hi < 49 && return sieve - small_sieve = _primesmask(isqrt(hi)) - @inbounds for i = 1:length(small_sieve) # don't use eachindex here - if small_sieve[i]; p = wheel_prime(i) - j = wheel_index(2 * div(lo - p - 1, 2p) + 1) - q = p * wheel_prime(j + 1); j = j & 7 + 1 - while q ≤ m - sieve[wheel_index(q)-wlo] = false - q = q + wheel[j] * p - j = j & 7 + 1 - end - end - end - return sieve -end - -# Sieve of the primes from lo up to hi represented as an array of booleans -function primesmask(lo::Int, hi::Int) - 0 < lo ≤ hi || throw(ArgumentError("the condition 0 < lo ≤ hi must be met")) - sieve = falses(hi - lo + 1) - lo ≤ 2 ≤ hi && (sieve[3-lo] = true) - lo ≤ 3 ≤ hi && (sieve[4-lo] = true) - lo ≤ 5 ≤ hi && (sieve[6-lo] = true) - hi < 7 && return sieve - wheel_sieve = _primesmask(max(7, lo), hi) - lsi = lo - 1 - lwi = wheel_index(lsi) - @inbounds for i = 1:length(wheel_sieve) # don't use eachindex here - sieve[wheel_prime(i + lwi) - lsi] = wheel_sieve[i] - end - return sieve -end -primesmask{T<:Integer}(lo::T, hi::T) = lo <= hi <= typemax(Int) ? primesmask(Int(lo), Int(hi)) : - throw(ArgumentError("both endpoints of the interval to sieve must be ≤ $(typemax(Int)), got $lo and $hi")) - -primesmask(limit::Int) = primesmask(1, limit) -primesmask(n::Integer) = n <= typemax(Int) ? primesmask(Int(n)) : - throw(ArgumentError("requested number of primes must be ≤ $(typemax(Int)), got $n")) - -function primes(lo::Int, hi::Int) - lo ≤ hi || throw(ArgumentError("the condition lo ≤ hi must be met")) - list = Int[] - lo ≤ 2 ≤ hi && push!(list, 2) - lo ≤ 3 ≤ hi && push!(list, 3) - lo ≤ 5 ≤ hi && push!(list, 5) - hi < 7 && return list - sizehint!(list, floor(Int, hi / log(hi))) - sieve = _primesmask(max(7, lo), hi) - lwi = wheel_index(lo - 1) - @inbounds for i = 1:length(sieve) # don't use eachindex here - sieve[i] && push!(list, wheel_prime(i + lwi)) - end - return list -end -primes(n::Int) = primes(1, n) - -const PRIMES = primes(2^16) - -# Small precomputed primes + Miller-Rabin for primality testing: -# https://en.wikipedia.org/wiki/Miller–Rabin_primality_test -# -function isprime(n::Integer) - (n < 3 || iseven(n)) && return n == 2 - n <= 2^16 && return PRIMES[searchsortedlast(PRIMES,n)] == n - s = trailing_zeros(n-1) - d = (n-1) >>> s - for a in witnesses(n) - x = powermod(a,d,n) - x == 1 && continue - t = s - while x != n-1 - (t-=1) <= 0 && return false - x = oftype(n, widemul(x,x) % n) - x == 1 && return false - end - end - return true -end - -# Miller-Rabin witness choices based on: -# http://mathoverflow.net/questions/101922/smallest-collection-of-bases-for-prime-testing-of-64-bit-numbers -# http://primes.utm.edu/prove/merged.html -# http://miller-rabin.appspot.com -# -witnesses(n::Union{UInt8,Int8,UInt16,Int16}) = (2,3) -witnesses(n::Union{UInt32,Int32}) = n < 1373653 ? (2,3) : (2,7,61) -witnesses(n::Union{UInt64,Int64}) = - n < 1373653 ? (2,3) : - n < 4759123141 ? (2,7,61) : - n < 2152302898747 ? (2,3,5,7,11) : - n < 3474749660383 ? (2,3,5,7,11,13) : - (2,325,9375,28178,450775,9780504,1795265022) - -isprime(n::UInt128) = - n <= typemax(UInt64) ? isprime(UInt64(n)) : isprime(BigInt(n)) -isprime(n::Int128) = n < 2 ? false : - n <= typemax(Int64) ? isprime(Int64(n)) : isprime(BigInt(n)) - - -# Trial division of small (< 2^16) precomputed primes + -# Pollard rho's algorithm with Richard P. Brent optimizations -# https://en.wikipedia.org/wiki/Trial_division -# https://en.wikipedia.org/wiki/Pollard%27s_rho_algorithm -# http://maths-people.anu.edu.au/~brent/pub/pub051.html -# -function factor{T<:Integer}(n::T) - 0 < n || throw(ArgumentError("number to be factored must be ≥ 0, got $n")) - h = Dict{T,Int}() - n == 1 && return h - isprime(n) && (h[n] = 1; return h) - local p::T - for p in PRIMES - if n % p == 0 - h[p] = get(h,p,0)+1 - n = div(n,p) - while n % p == 0 - h[p] = get(h,p,0)+1 - n = div(n,p) - end - n == 1 && return h - isprime(n) && (h[n] = 1; return h) - end - end - T <: BigInt || widemul(n-1,n-1) <= typemax(n) ? pollardfactors!(n, h) : pollardfactors!(widen(n), h) -end - -function pollardfactors!{T<:Integer,K<:Integer}(n::T, h::Dict{K,Int}) - while true - local c::T = rand(1:(n-1)), G::T = 1, r::K = 1, y::T = rand(0:(n-1)), m::K = 1900 - local ys::T, q::T = 1, x::T - while c == n - 2 - c = rand(1:(n-1)) - end - while G == 1 - x = y - for i in 1:r - y = (y*y)%n - y = (y+c)%n - end - local k::K = 0 - G = 1 - while k < r && G == 1 - for i in 1:(m>(r-k)?(r-k):m) - ys = y - y = (y*y)%n - y = (y+c)%n - q = (q*(x>y?x-y:y-x))%n - end - G = gcd(q,n) - k = k + m - end - r = 2 * r - end - G == n && (G = 1) - while G == 1 - ys = (ys*ys)%n - ys = (ys+c)%n - G = gcd(x>ys?x-ys:ys-x,n) - end - if G != n - isprime(G) ? h[G] = get(h,G,0) + 1 : pollardfactors!(G,h) - G2 = div(n,G) - isprime(G2) ? h[G2] = get(h,G2,0) + 1 : pollardfactors!(G2,h) - return h - end - end -end diff --git a/base/sysimg.jl b/base/sysimg.jl index c5ae20327a50b..0991f6d58d2ea 100644 --- a/base/sysimg.jl +++ b/base/sysimg.jl @@ -179,8 +179,6 @@ include("multidimensional.jl") include("permuteddimsarray.jl") using .PermutedDimsArrays -include("primes.jl") - let SOURCE_PATH = "" global include = function(path) prev = SOURCE_PATH diff --git a/contrib/BBEditTextWrangler-julia.plist b/contrib/BBEditTextWrangler-julia.plist index fcb01a678c577..2e0a4a5a19a09 100644 --- a/contrib/BBEditTextWrangler-julia.plist +++ b/contrib/BBEditTextWrangler-julia.plist @@ -423,7 +423,6 @@ export extrema eye - factor factorial factorize falses @@ -633,7 +632,6 @@ isposdef! isposdef ispow2 - isprime isprint ispunct isqrt @@ -849,8 +847,6 @@ prevind prevpow2 prevpow - primes - primesmask print print_escaped print_joined diff --git a/doc/manual/arrays.rst b/doc/manual/arrays.rst index c0b03cd4763c4..fd2fd6b3037f7 100644 --- a/doc/manual/arrays.rst +++ b/doc/manual/arrays.rst @@ -319,14 +319,13 @@ Example: 6 10 7 11 - julia> x[map(isprime, x)] - 6-element Array{Int64,1}: + julia> x[map(ispow2, x)] + 5-element Array{Int64,1}: + 1 2 - 3 - 5 - 7 - 11 - 13 + 4 + 8 + 16 julia> x[1, [2 3; 4 1]] 2x2 Array{Int64,2}: diff --git a/doc/stdlib/math.rst b/doc/stdlib/math.rst index fea8aeb27377d..46529bfdd07e9 100644 --- a/doc/stdlib/math.rst +++ b/doc/stdlib/math.rst @@ -1359,19 +1359,6 @@ Mathematical Functions Compute ``factorial(n)/factorial(k)``\ . -.. function:: factor(n) -> Dict - - .. Docstring generated from Julia source - - Compute the prime factorization of an integer ``n``\ . Returns a dictionary. The keys of the dictionary correspond to the factors, and hence are of the same type as ``n``\ . The value associated with each key indicates the number of times the factor appears in the factorization. - - .. doctest:: - - julia> factor(100) # == 2*2*5*5 - Dict{Int64,Int64} with 2 entries: - 2 => 2 - 5 => 2 - .. function:: gcd(x,y) .. Docstring generated from Julia source diff --git a/doc/stdlib/numbers.rst b/doc/stdlib/numbers.rst index 2b55a16149bab..62d672eab244f 100644 --- a/doc/stdlib/numbers.rst +++ b/doc/stdlib/numbers.rst @@ -455,40 +455,6 @@ Integers julia> trailing_ones(3) 2 -.. function:: isprime(x::Integer) -> Bool - - .. Docstring generated from Julia source - - Returns ``true`` if ``x`` is prime, and ``false`` otherwise. - - .. doctest:: - - julia> isprime(3) - true - -.. function:: isprime(x::BigInt, [reps = 25]) -> Bool - - .. Docstring generated from Julia source - - Probabilistic primality test. Returns ``true`` if ``x`` is prime; and ``false`` if ``x`` is not prime with high probability. The false positive rate is about ``0.25^reps``\ . ``reps = 25`` is considered safe for cryptographic applications (Knuth, Seminumerical Algorithms). - - .. doctest:: - - julia> isprime(big(3)) - true - -.. function:: primes([lo,] hi) - - .. Docstring generated from Julia source - - Returns a collection of the prime numbers (from ``lo``\ , if specified) up to ``hi``\ . - -.. function:: primesmask([lo,] hi) - - .. Docstring generated from Julia source - - Returns a prime sieve, as a ``BitArray``\ , of the positive integers (from ``lo``\ , if specified) up to ``hi``\ . Useful when working with either primes or composite numbers. - .. function:: isodd(x::Integer) -> Bool .. Docstring generated from Julia source diff --git a/test/bigint.jl b/test/bigint.jl index 90a318926ed2a..451ae3716e52c 100644 --- a/test/bigint.jl +++ b/test/bigint.jl @@ -217,12 +217,6 @@ g = parse(BigInt,"-1") @test (|)(a, b, c, d, f) == parse(BigInt,"-1358954753") @test (|)(a, b, c, d, f, g) == parse(BigInt,"-1") -@test isprime(BigInt(1000000007)) -@test isprime(BigInt(1000000007), 1) -@test isprime(BigInt(10000000019)) -@test isprime(parse(BigInt,"359334085968622831041960188598043661065388726959079837")) -@test !isprime(BigInt(1)) -@test !isprime(BigInt(10000000020)) @test trailing_ones(a) == 8 @test trailing_zeros(b) == 2 diff --git a/test/euler.jl b/test/euler.jl index b3aef922012ab..d4ef4744831f7 100644 --- a/test/euler.jl +++ b/test/euler.jl @@ -21,9 +21,6 @@ function euler2(n) end @test euler2(4000000) == 4613732 -#3: 6857 -@test maximum(keys(factor(600851475143))) == 6857 - #4: 906609 function euler4(n) m = 1 @@ -47,10 +44,6 @@ end #6: 25164150 @test sum(1:100)^2 - sum((1:100).^2) == 25164150 -#7: 104743 -euler7(n) = primes(floor(Int,n*log(n*log(n))))[n] -@test euler7(10001) == 104743 - #8: 40824 function euler8(n,m) d = digits(n) @@ -68,8 +61,6 @@ function euler9(n) end @test euler9(1000) == 31875000 -#10: 142913828922 -@test sum(map(Int64,primes(2000000))) == 142913828922 #11: 70600674 function euler11(grid,n) diff --git a/test/numbers.jl b/test/numbers.jl index 73eaa0c0dd363..8e220dcaecf7a 100644 --- a/test/numbers.jl +++ b/test/numbers.jl @@ -1747,13 +1747,6 @@ end @test_throws InexactError round(UInt32, 4.2949673f9) @test round(UInt32, 4.294967f9) == 0xffffff00 -for n = 1:100 - m = 1 - for (p,k) in factor(n) - m *= p^k - end - @test n == m -end for Ti in [Int,UInt] for Tf in [Float16,Float32,Float64] @@ -2137,174 +2130,10 @@ for f in (trunc, round, floor, ceil) # issue 16311 rationalize(nextfloat(0.0)) == 0//1 - -# primes - -@test primes(10000) == primes(2, 10000) == [ - 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, - 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, - 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, - 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, - 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, - 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, - 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, - 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, - 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, - 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, - 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, - 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, - 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, - 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, - 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, - 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, - 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, - 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, - 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, - 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, - 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, - 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, - 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, - 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, - 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, - 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, - 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, - 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, - 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, - 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, - 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, - 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, - 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, - 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, - 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, - 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, - 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, - 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, - 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, - 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, - 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, - 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, - 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, - 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, - 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, - 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, - 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, - 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, - 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, - 4643, 4649, 4651, 4657, 4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, - 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, - 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, - 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, - 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, - 5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, - 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, - 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, - 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, - 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, - 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, - 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, - 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, - 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, - 6091, 6101, 6113, 6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, - 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, - 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, - 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491, - 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, - 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, - 6719, 6733, 6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, - 6829, 6833, 6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, - 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013, - 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 7127, 7129, - 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, - 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, - 7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, - 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, - 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, - 7687, 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, - 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, - 7907, 7919, 7927, 7933, 7937, 7949, 7951, 7963, 7993, 8009, 8011, 8017, - 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123, - 8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 8233, 8237, - 8243, 8263, 8269, 8273, 8287, 8291, 8293, 8297, 8311, 8317, 8329, 8353, - 8363, 8369, 8377, 8387, 8389, 8419, 8423, 8429, 8431, 8443, 8447, 8461, - 8467, 8501, 8513, 8521, 8527, 8537, 8539, 8543, 8563, 8573, 8581, 8597, - 8599, 8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681, 8689, - 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747, 8753, 8761, 8779, - 8783, 8803, 8807, 8819, 8821, 8831, 8837, 8839, 8849, 8861, 8863, 8867, - 8887, 8893, 8923, 8929, 8933, 8941, 8951, 8963, 8969, 8971, 8999, 9001, - 9007, 9011, 9013, 9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103, 9109, - 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203, 9209, - 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293, 9311, 9319, 9323, - 9337, 9341, 9343, 9349, 9371, 9377, 9391, 9397, 9403, 9413, 9419, 9421, - 9431, 9433, 9437, 9439, 9461, 9463, 9467, 9473, 9479, 9491, 9497, 9511, - 9521, 9533, 9539, 9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, - 9643, 9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739, 9743, - 9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, 9817, 9829, 9833, 9839, - 9851, 9857, 9859, 9871, 9883, 9887, 9901, 9907, 9923, 9929, 9931, 9941, - 9949, 9967, 9973 ] - -for n = 100:100:1000 - @test primes(n, 10n) == primes(10n)[length(primes(n))+1:end] - @test primesmask(n, 10n) == primesmask(10n)[n:end] -end - -for T in [Int,BigInt], n = [1:1000;1000000] - n = convert(T,n) - f = factor(n) - @test n == prod(T[p^k for (p,k)=f]) - prime = n!=1 && length(f)==1 && get(f,n,0)==1 - @test isprime(n) == prime - - s = primesmask(n) - for k = 1:n - @test s[k] == isprime(k) - @test s[k] == primesmask(k, k)[1] - end -end - -@test !isprime(1000000003) -@test !isprime(1000000005) -@test isprime(1000000007) -@test isprime(1000000009) -@test !isprime(1000000011) -@test !isprime(1000000013) - -@test !isprime(10000000015) -@test !isprime(10000000017) -@test isprime(10000000019) -@test !isprime(10000000021) -@test !isprime(10000000023) - -@test !isprime(9223372036854775779) -@test !isprime(9223372036854775781) -@test isprime(9223372036854775783) -@test !isprime(9223372036854775785) -@test !isprime(9223372036854775787) - -@test !isprime(0xffffffffffffffc1) -@test !isprime(0xffffffffffffffc3) -@test isprime(0xffffffffffffffc5) -@test !isprime(0xffffffffffffffc7) -@test !isprime(0xffffffffffffffc9) - -for T in [Int8,UInt8,Int16,UInt16,Int128,UInt128] - @test isprime(T(2)) - @test !isprime(T(4)) -end - -# issue #5210 -@test prod([ k^v for (k,v) in factor(typemax(UInt32)) ]) == typemax(UInt32) -@test prod([ k^v for (k,v) in factor(typemax(Int8)) ]) == typemax(Int8) - # rational-exponent promotion rules (issue #3155): @test 2.0f0^(1//3) == 2.0f0^(1.0f0/3) @test 2^(1//3) == 2^(1/3) -# factorization of factors > 2^16 -@test factor((big(2)^31-1)^2) == Dict(big(2^31-1) => 2) -@test factor((big(2)^31-1)*(big(2)^17-1)) == Dict(big(2^31-1) => 1, big(2^17-1) => 1) - -# fast factorization of Int128 (#11477) -@test factor((Int128(2)^39-7)^2) == Dict(Int128(2)^39-7 => 2) # large shift amounts @test Int32(-1)>>31 == -1 @@ -2615,11 +2444,6 @@ let x = big(-0.0) @test signbit(x) && !signbit(abs(x)) end -# issue #9611 -@test factor(Int128(2)^101+1) == Dict(3=>1,845100400152152934331135470251=>1) - -# test second branch, after all small primes in list have been searched -@test factor(10009 * Int128(1000000000000037)) == Dict(10009=>1,1000000000000037=>1) @test all(x -> (m=mod1(x,3); 0 x == (fld1(x,3)-1)*3 + mod1(x,3), -5:+5)