upgradathon: require 0.7 (#61)

Author: rfourquet

.travis.yml

@@ -3,7 +3,7 @@ language: julia
 os:
   - linux
 julia:
-  - 0.6
+  - 0.7
   - nightly
 notifications:
   email: false

README.md

@@ -1,6 +1,5 @@
 # Primes.jl
 
-[![Primes](http://pkg.julialang.org/badges/Primes_0.6.svg)](http://pkg.julialang.org/?pkg=Primes)
 [![Primes](http://pkg.julialang.org/badges/Primes_0.7.svg)](http://pkg.julialang.org/?pkg=Primes)
 [![Build Status](https://travis-ci.org/JuliaMath/Primes.jl.svg?branch=master)](https://travis-ci.org/JuliaMath/Primes.jl)
 [![Windows Build](https://ci.appveyor.com/api/projects/status/ao64pk44lwo0092r/branch/master?svg=true)](https://ci.appveyor.com/project/ararslan/primes-jl/branch/master)

REQUIRE

@@ -1,2 +1 @@
-julia 0.6
-Compat 0.30.0
+julia 0.7-alpha

appveyor.yml

@@ -1,7 +1,7 @@
 environment:
   matrix:
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.6/julia-0.6-latest-win32.exe"
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.6/julia-0.6-latest-win64.exe"
+  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.7/julia-0.7-latest-win32.exe"
+  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.7/julia-0.7-latest-win64.exe"
   - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x86/julia-latest-win32.exe"
   - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x64/julia-latest-win64.exe"
 

docs/src/index.md

@@ -4,23 +4,12 @@ This package provides functions for computing prime numbers in Julia.
 
 ## Installation
 
-The package is available for Julia versions 0.4 and up.
+The package is available for Julia versions 0.4 and up, but if you are
+not using Julia version 0.7 or higher, please read the documentation for the
+appropriate realease.
+
 To install it, run
 ```julia
 Pkg.add("Primes")
 ```
 from the Julia REPL.
-
-## Note
-
-Prior to Julia 0.5, these (or similar) functions were available in Julia's Base module.
-Because of this, the symbols from this package are not exported on Julia 0.4 to avoid
-naming conflicts.
-In this case, the symbols will need to be explicitly imported or called with the prefix
-`Primes`.
-For example,
-```julia
-using Primes
-import Primes: isprime, primes, primesmask, factor
-```
-This is not necessary for Julia versions 0.5 or later.

src/Primes.jl

@@ -1,20 +1,14 @@
 # This includes parts that were formerly a part of Julia. License is MIT: http://julialang.org/license
-__precompile__()
+#__precompile__()
 module Primes
 
-using Compat
-using Compat.Iterators: repeated
-
-if isdefined(Base,:isprime)
-    import Base: isprime, primes, primesmask, factor
-else
-    export isprime, primes, primesmask, factor
-end
+using Base.Iterators: repeated
 
 using Base: BitSigned
 using Base.Checked: checked_neg
 
-export ismersenneprime, isrieselprime, nextprime, prevprime, prime, prodfactors, radical, totient
+export isprime, primes, primesmask, factor, ismersenneprime, isrieselprime,
+       nextprime, prevprime, prime, prodfactors, radical, totient
 
 include("factorization.jl")
 
@@ -344,8 +338,13 @@ Set([2,5])
 """
 factor(::Type{D}, n::T) where {T<:Integer, D<:AbstractDict} = factor!(n, D(Dict{T,Int}()))
 factor(::Type{A}, n::T) where {T<:Integer, A<:AbstractArray} = A(factor(Vector{T}, n))
-factor(::Type{Vector{T}}, n::T) where {T<:Integer} =
-    mapreduce(collect, vcat, Vector{T}(), [repeated(k, v) for (k, v) in factor(n)])
+if VERSION >= v"0.7.0-beta.81"
+    factor(::Type{Vector{T}}, n::T) where {T<:Integer} =
+        mapreduce(collect, vcat, [repeated(k, v) for (k, v) in factor(n)], init=Vector{T}())
+else
+    factor(::Type{Vector{T}}, n::T) where {T<:Integer} =
+        mapreduce(collect, vcat, Vector{T}(), [repeated(k, v) for (k, v) in factor(n)])
+end
 factor(::Type{S}, n::T) where {T<:Integer, S<:Union{Set,BitSet}} = S(keys(factor(n)))
 factor(::Type{T}, n) where {T<:Any} = throw(MethodError(factor, (T, n)))
 
@@ -436,6 +435,12 @@ function pollardfactors!(n::T, h::AbstractDict{K,Int}) where {T<:Integer,K<:Inte
     end
 end
 
+if VERSION >= v"0.7.0-beta.183"
+    ndigits2(n) = ndigits(n, base=2)
+else
+    ndigits2(n) = ndigits(n, 2)
+end
+
 """
     ismersenneprime(M::Integer; [check::Bool = true]) -> Bool
 
@@ -456,7 +461,7 @@ true
 """
 function ismersenneprime(M::Integer; check::Bool = true)
     if check
-        d = ndigits(M, 2)
+        d = ndigits2(M)
         M >= 0 && isprime(d) && (M >> d == 0) ||
             throw(ArgumentError("The argument given is not a valid Mersenne Number (`M = 2^p - 1`)."))
     end
@@ -481,7 +486,7 @@ true
 ```
 """
 function isrieselprime(k::Integer, Q::Integer)
-    n = ndigits(Q, 2)
+    n = ndigits2(Q)
     0 < k < Q || throw(ArgumentError("The condition 0 < k < Q must be met."))
     if k == 1 && isodd(n)
         return n % 4 == 3 ? ll_primecheck(Q, 3) : ll_primecheck(Q)
@@ -495,7 +500,7 @@ end
 
 # LL backend -- not for export
 function ll_primecheck(X::Integer, s::Integer = 4)
-    S, N = BigInt(s), BigInt(ndigits(X, 2))
+    S, N = BigInt(s), BigInt(ndigits2(X))
     X < 7 && throw(ArgumentError("The condition X ≥ 7 must be met."))
     for i in 1:(N - 2)
         S = (S^2 - 2) % X

src/factorization.jl

@@ -4,7 +4,6 @@
 struct Factorization{T<:Integer} <: AbstractDict{T, Int}
     pe::Vector{Pair{T, Int}} # Prime-Exponent
 
-    # Factorization{T}() where {T} = new(Vector{Pair{T, Int}}())
     Factorization{T}() where {T<:Integer} = new{T}(Vector{Pair{T, Int}}())
 end
 
@@ -14,12 +13,10 @@ function Factorization{T}(d::AbstractDict) where T<:Integer
     f
 end
 
-Base.convert(::Type{Factorization}, d::AbstractDict{T}) where {T} = Factorization{T}(d)
-
-Base.start(f::Factorization) = start(f.pe)
-Base.next(f::Factorization, i) = next(f.pe, i)
-Base.done(f::Factorization, i) = done(f.pe, i)
+Factorization(d::AbstractDict{T}) where {T<:Integer} = Factorization{T}(d)
+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)

test/runtests.jl

@@ -1,6 +1,5 @@
 using Primes
-using Compat
-using Compat.Test
+using Test
 using DataStructures: SortedDict
 
 import Primes: isprime, primes, primesmask, factor, ismersenneprime, isrieselprime, Factorization