Update package to 0.7

Author: timholy

.travis.yml

@@ -4,8 +4,8 @@ os:
   - linux
   - osx
 julia:
-  - 0.5
-  - 0.6
+  - 0.7
+  - 1.0
   - nightly
 notifications:
   email: false
@@ -15,4 +15,4 @@ notifications:
 #  - julia -e 'Pkg.clone(pwd()); Pkg.build("RoundingIntegers"); Pkg.test("RoundingIntegers"; coverage=true)'
 after_success:
   # push coverage results to Codecov
-  - julia -e 'cd(Pkg.dir("RoundingIntegers")); Pkg.add("Coverage"); using Coverage; Codecov.submit(Codecov.process_folder())'
+  - julia -e 'using RoundingIntegers, Pkg; cd(dirname(dirname(pathof(RoundingIntegers)))); Pkg.add("Coverage"); using Coverage; Codecov.submit(Codecov.process_folder())'

REQUIRE

@@ -1,2 +1 @@
 julia 0.7
-Compat 0.17

appveyor.yml

@@ -1,9 +1,18 @@
 environment:
   matrix:
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.5/julia-0.5-latest-win32.exe"
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.5/julia-0.5-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"
+  - julia_version: 0.7
+  - julia_version: 1
+  - julia_version: nightly
+
+platform:
+  - x86 # 32-bit
+  - x64 # 64-bit
+
+# # Uncomment the following lines to allow failures on nightly julia
+# # (tests will run but not make your overall status red)
+# matrix:
+#   allow_failures:
+#   - julia_version: nightly
 
 branches:
   only:
@@ -17,19 +26,18 @@ notifications:
     on_build_status_changed: false
 
 install:
-  - ps: "[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]::Tls12"
-# Download most recent Julia Windows binary
-  - ps: (new-object net.webclient).DownloadFile(
-        $env:JULIA_URL,
-        "C:\projects\julia-binary.exe")
-# Run installer silently, output to C:\projects\julia
-  - C:\projects\julia-binary.exe /S /D=C:\projects\julia
+  - ps: iex ((new-object net.webclient).DownloadString("https://raw.githubusercontent.com/JuliaCI/Appveyor.jl/version-1/bin/install.ps1"))
 
 build_script:
-# Need to convert from shallow to complete for Pkg.clone to work
-  - IF EXIST .git\shallow (git fetch --unshallow)
-  - C:\projects\julia\bin\julia -e "versioninfo();
-      Pkg.clone(pwd(), \"RoundingIntegers\"); Pkg.build(\"RoundingIntegers\")"
+  - echo "%JL_BUILD_SCRIPT%"
+  - C:\julia\bin\julia -e "%JL_BUILD_SCRIPT%"
 
 test_script:
-  - C:\projects\julia\bin\julia -e "Pkg.test(\"RoundingIntegers\")"
+  - echo "%JL_TEST_SCRIPT%"
+  - C:\julia\bin\julia -e "%JL_TEST_SCRIPT%"
+
+# # Uncomment to support code coverage upload. Should only be enabled for packages
+# # which would have coverage gaps without running on Windows
+# on_success:
+#   - echo "%JL_CODECOV_SCRIPT%"
+#   - C:\julia\bin\julia -e "%JL_CODECOV_SCRIPT%"

src/RoundingIntegers.jl

@@ -1,7 +1,6 @@
 module RoundingIntegers
 
-using Compat
-import Base: <, <=, +, -, *, ~, &, |, $, <<, >>, >>>
+import Base: <, <=, +, -, *, ~, &, |, <<, >>, >>>, xor
 
 export RSigned, RUnsigned, RInteger
 export RInt8, RUInt8, RInt16, RUInt16, RInt32, RUInt32, RInt64, RUInt64,
@@ -63,62 +62,40 @@ rtype(x::Union{Signed,Unsigned}) = rtype(typeof(x))
 # RIntegers are largely about assignment; for usage, we convert to
 # standard integers at the drop of a hat.
 
-Base.promote_rule(::Type{T}, ::Type{RI}) where {T<:Number,RI<:RInteger} =
+Base.promote_rule(::Type{RI}, ::Type{T}) where {T<:Number,RI<:RInteger} =
     promote_type(T, itype(RI))
-# Resolve ambiguities
-Base.promote_rule(::Type{Bool}, ::Type{RI}) where {RI<:RInteger} =
-    promote_type(Bool, itype(RI))
-Base.promote_rule(::Type{BigInt}, ::Type{RI}) where {RI<:RInteger} =
-    promote_type(BigInt, itype(RI))
-Base.promote_rule(::Type{BigFloat}, ::Type{RI}) where {RI<:RInteger} =
-    promote_type(BigFloat, itype(RI))
-Base.promote_rule(::Type{Complex{T}}, ::Type{RI}) where {T<:Real,RI<:RInteger} =
-    promote_type(Complex{T}, itype(RI))
-Base.promote_rule(::Type{Rational{T}}, ::Type{RI}) where {T<:Integer,RI<:RInteger} =
-    promote_type(Rational{T}, itype(RI))
-Base.promote_rule(::Type{<:Irrational}, ::Type{RI}) where {RI<:RInteger} =
-    promote_type(Float64, itype(RI))
-
-Signed(x::RSigned) = reinterpret(itype(x), x)
-Unsigned(x::RUnsigned) = reinterpret(itype(x), x)
+
+Base.Signed(x::RSigned) = reinterpret(itype(x), x)
+Base.Unsigned(x::RUnsigned) = reinterpret(itype(x), x)
 RSigned(x::Signed) = reinterpret(rtype(x), x)
 RUnsigned(x::Unsigned) = reinterpret(rtype(x), x)
-Integer(x::RSigned) = Signed(x)
-Integer(x::RUnsigned) = Unsigned(x)
+Base.Integer(x::RSigned) = Signed(x)
+Base.Integer(x::RUnsigned) = Unsigned(x)
 RInteger(x::Signed) = RSigned(x)
 RInteger(x::Unsigned) = RUnsigned(x)
 
-# Basic conversions
-# @inline Base.convert{T<:RSigned}(::Type{T}, x::T) = x
-# @inline Base.convert{T<:RUnsigned}(::Type{T}, x::T) = x
-@inline Base.convert(::Type{T}, x::T) where {T<:RInteger} = x
-@inline Base.convert(::Type{T}, x::RInteger) where {T<:RInteger} =
-    RInteger(convert(itype(T), Integer(x)))
-@inline Base.convert(::Type{T}, x::Integer) where {T<:RInteger} = RInteger(convert(itype(T), x))
-@inline Base.convert(::Type{T}, x::AbstractFloat) where {T<:RInteger} =
-    RInteger(round(itype(T), digits=x))
-@inline Base.convert(::Type{T}, x::Number) where {T<:RInteger} =
-    convert(T, convert(itype(T), x))
+Base.AbstractFloat(x::RInteger) = AbstractFloat(Integer(x))
+
+RInt8(x::Int8) = reinterpret(RInt8, x)
+RUInt8(x::UInt8) = reinterpret(RUInt8, x)
+RInt16(x::Int16) = reinterpret(RInt16, x)
+RUInt16(x::UInt16) = reinterpret(RUInt16, x)
+RInt32(x::Int32) = reinterpret(RInt32, x)
+RUInt32(x::UInt32) = reinterpret(RUInt32, x)
+RInt64(x::Int64) = reinterpret(RInt64, x)
+RUInt64(x::UInt64) = reinterpret(RUInt64, x)
+RInt128(x::Int128) = reinterpret(RInt128, x)
+RUInt128(x::UInt128) = reinterpret(RUInt128, x)
+
+(::Type{R})(x::Integer) where R<:RInteger = R(convert(itype(R), x))
+(::Type{R})(x::Float16) where R<:RInteger = R(round(itype(R), x))
+(::Type{R})(x::BigFloat) where R<:RInteger = R(round(itype(R), x))
+(::Type{R})(x::Rational) where R<:RInteger = R(round(itype(R), x))
+(::Type{R})(x::Complex) where R<:RInteger = R(round(itype(R), x))
+(::Type{R})(x::AbstractFloat) where R<:RInteger = R(round(itype(R), x))
 
 @inline Base.convert(::Type{T}, x::RInteger) where {T<:Number} = convert(T, Integer(x))
 
-# Resolve ambiguities
-Base.convert(::Type{Integer}, x::RInteger) = Integer(x)
-Base.convert(::Type{BigInt}, x::RInteger) = convert(BigInt, Integer(x))
-Base.convert(::Type{T}, x::BigInt) where {T<:RInteger} = RInteger(convert(itype(T), x))
-Base.convert(::Type{BigFloat}, x::RInteger) = convert(BigFloat, Integer(x))
-Base.convert(::Type{T}, x::BigFloat) where {T<:RInteger} = RInteger(convert(itype(T), x))
-Base.convert(::Type{Complex{T}}, x::RInteger) where {T<:Real} = convert(Complex{T}, Integer(x))
-Base.convert(::Type{T}, z::Complex) where {T<:RInteger} = RInteger(convert(itype(T), z))
-Base.convert(::Type{Complex}, x::RInteger) = Complex(x)
-Base.convert(::Type{T}, x::Rational) where {T<:RInteger} = RInteger(convert(itype(T)), x)
-Base.convert(::Type{Rational{T}}, x::RInteger) where {T<:Integer} =
-    convert(Rational{T}, Integer(x))
-Base.convert(::Type{Rational}, x::RInteger) = convert(Rational{typeof(x)}, x)
-Base.convert(::Type{Float16}, x::RInteger) = convert(Float16, Integer(x))
-Base.convert(::Type{T}, x::Float16) where {T<:RInteger} = RInteger(convert(itype(T), x))
-Base.convert(::Type{Bool}, x::RInteger) = convert(Bool, Integer(x))
-
 # rem conversions
 @inline Base.rem(x::T, ::Type{T}) where {T<:RInteger} = T
 @inline Base.rem(x::Integer, ::Type{T}) where {T<:RInteger} = RInteger(rem(x, itype(T)))
@@ -135,6 +112,8 @@ Base.count_ones(x::RInteger) = count_ones(Integer(x))
 Base.leading_zeros(x::RInteger) = leading_zeros(Integer(x))
 Base.trailing_zeros(x::RInteger) = trailing_zeros(Integer(x))
 Base.ndigits0z(x::RInteger) = Base.ndigits0z(Integer(x))
+Base.ndigits0zpb(x::RSigned, b::Integer) = Base.ndigits0zpb(abs(Integer(x)), Int(b))
+Base.ndigits0zpb(x::RUnsigned, b::Integer) = Base.ndigits0zpb(Integer(x), Int(b))
 
 # A few operations preserve the type
 -(x::RInteger) = RInteger(-Integer(x))
@@ -156,8 +135,7 @@ Base.ndigits0z(x::RInteger) = Base.ndigits0z(Integer(x))
 *(x::T, y::T) where {T<:RInteger} = RInteger(Integer(x) * Integer(y))
 (&)(x::T, y::T) where {T<:RInteger} = RInteger(Integer(x) & Integer(y))
 (|)(x::T, y::T) where {T<:RInteger} = RInteger(Integer(x) | Integer(y))
-# ($){T<:RInteger}(x::T, y::T) = RInteger(Integer(x) $ Integer(y))
-Compat.xor(x::T, y::T) where {T<:RInteger} = RInteger(xor(Integer(x), Integer(y)))
+xor(x::T, y::T) where {T<:RInteger} = RInteger(xor(Integer(x), Integer(y)))
 
 Base.rem(x::T, y::T) where {T<:RInteger} = RInteger(rem(Integer(x), Integer(y)))
 Base.mod(x::T, y::T) where {T<:RInteger} = RInteger(mod(Integer(x), Integer(y)))

test/runtests.jl

@@ -1,8 +1,6 @@
-using Compat, Test
-ambs0 = detect_ambiguities(Base, Core, Compat)
+using Test
 using RoundingIntegers
-ambs1 = detect_ambiguities(Base, Core, Compat, RoundingIntegers)
-@test isempty(setdiff(ambs1, ambs0))
+@test isempty(detect_ambiguities(Base, Core, RoundingIntegers))
 
 @testset "Basics" begin
     r16 = RInt16(3)
@@ -57,7 +55,7 @@ ambs1 = detect_ambiguities(Base, Core, Compat, RoundingIntegers)
     @test !signbit(r)
     @test copysign(r, r) === r
     @test unsigned(r) === RUInt(5)
-    @test hex(r) == "5"
+    @test string(r, base=16) == "5"
 
     @test string(RInt(7.2)) == "7"
 end