Integers in the type domain

base/Base.jl

@@ -305,6 +305,7 @@ end
 # numeric operations
 include("hashing.jl")
 include("rounding.jl")
+include("typedomainintegers.jl"); using .TypeDomainIntegers
 include("div.jl")
 include("rawbigints.jl")
 include("float.jl")
@@ -521,6 +522,8 @@ include("irrationals.jl")
 include("mathconstants.jl")
 using .MathConstants: ℯ, π, pi
 
+include("typedomainintegers_irrationals.jl")
+
 # Stack frames and traces
 include("stacktraces.jl")
 using .StackTraces

base/complex.jl

@@ -86,7 +86,7 @@ julia> imag(1 + 3im)
 """
 imag(z::Complex) = z.im
 real(x::Real) = x
-imag(x::Real) = zero(x)
+imag(@nospecialize x::Real) = zero(NonnegativeInteger)
 
 """
     reim(z)
@@ -613,6 +613,14 @@ julia> cispi(0.25 + 1im)
 """
 function cispi end
 cispi(theta::Real) = Complex(reverse(sincospi(theta))...)
+function cispi(@nospecialize n::TypeDomainInteger)
+    o = one(TypeDomainInteger)
+    if iseven(n)
+        o
+    else
+        -o
+    end
+end
 
 function cispi(z::Complex)
     v = exp(-(pi*imag(z)))

base/gmp.jl

@@ -13,6 +13,8 @@ import .Base: *, +, -, /, <, <<, >>, >>>, <=, ==, >, >=, ^, (~), (&), (|), xor,
              sign, hastypemax, isodd, iseven, digits!, hash, hash_integer, top_set_bit,
              clamp
 
+using ..TypeDomainIntegers
+
 if Clong == Int32
     const ClongMax = Union{Int8, Int16, Int32}
     const CulongMax = Union{UInt8, UInt16, UInt32}
@@ -389,6 +391,18 @@ function (::Type{T})(x::BigInt) where T<:Base.BitSigned
     end
 end
 
+function convert(::Type{NonnegativeInteger}, x::BigInt)
+    TypeDomainIntegers.Conversion.tdnn_from_x(x)
+end
+function convert(::Type{TypeDomainInteger}, x::BigInt)
+    TypeDomainIntegers.Conversion.tdi_from_x(x)
+end
+function NonnegativeInteger(x::BigInt)
+    TypeDomainIntegers.Conversion.tdnn_from_x(x)
+end
+function TypeDomainInteger(x::BigInt)
+    TypeDomainIntegers.Conversion.tdi_from_x(x)
+end
 
 Float64(n::BigInt, ::RoundingMode{:ToZero}) = MPZ.get_d(n)
 
@@ -566,6 +580,17 @@ end
 /(x::BigInt, y::Union{ClongMax,CulongMax}) = float(x)/y
 /(x::Union{ClongMax,CulongMax}, y::BigInt) = x/float(y)
 
+for func ∈ (:+, :-, :*, :(==))
+    @eval begin
+        function Base.$func((@nospecialize l::BigInt), (@nospecialize r::TypeDomainInteger))
+            TypeDomainIntegers.BaseHelpers.apply_n_t($func, l, r)
+        end
+        function Base.$func((@nospecialize l::TypeDomainInteger), (@nospecialize r::BigInt))
+            TypeDomainIntegers.BaseHelpers.apply_t_n($func, l, r)
+        end
+    end
+end
+
 # unary ops
 (-)(x::BigInt) = MPZ.neg(x)
 (~)(x::BigInt) = MPZ.com(x)

base/intfuncs.jl

@@ -299,6 +299,7 @@ end
 
 # ^ for any x supporting *
 to_power_type(x) = convert(Base._return_type(*, Tuple{typeof(x), typeof(x)}), x)
+to_power_type(@nospecialize x::TypeDomainInteger) = x
 @noinline throw_domerr_powbysq(::Any, p) = throw(DomainError(p, LazyString(
     "Cannot raise an integer x to a negative power ", p, ".",
     "\nConvert input to float.")))
@@ -1110,6 +1111,20 @@ function isqrt(x::Union{Int64,UInt64,Int128,UInt128})
     s*s > x ? s-1 : s
 end
 
+function isqrt(@nospecialize n::Union{
+    typeof(NonnegativeInteger(0)),
+    typeof(NonnegativeInteger(1)),
+    typeof(NonnegativeInteger(2)),
+    typeof(NonnegativeInteger(3)),
+})
+    z = zero(NonnegativeInteger)
+    if n isa PositiveIntegerUpperBound
+        natural_successor(z)
+    else
+        z
+    end
+end
+
 """
     factorial(n::Integer)
 
@@ -1145,6 +1160,19 @@ function factorial(n::Integer)
     return f
 end
 
+function factorial(@nospecialize n::Union{
+        typeof(NonnegativeInteger(0)),
+        typeof(NonnegativeInteger(1)),
+        typeof(NonnegativeInteger(2)),
+})
+    two = NonnegativeInteger(2)
+    if n === two
+        two
+    else
+        one(NonnegativeInteger)
+    end
+end
+
 """
     binomial(n::Integer, k::Integer)
 

base/irrationals.jl

@@ -109,6 +109,17 @@ end
 <=(x::AbstractIrrational, y::AbstractFloat) = x < y
 <=(x::AbstractFloat, y::AbstractIrrational) = x < y
 
+for func ∈ (:+, :-, :*, :(==))
+    @eval begin
+        function Base.$func((@nospecialize l::Irrational), (@nospecialize r::TypeDomainInteger))
+            TypeDomainIntegers.BaseHelpers.apply_n_t($func, l, r)
+        end
+        function Base.$func((@nospecialize l::TypeDomainInteger), (@nospecialize r::Irrational))
+            TypeDomainIntegers.BaseHelpers.apply_t_n($func, l, r)
+        end
+    end
+end
+
 # Irrational vs Rational
 @assume_effects :total function rationalize(::Type{T}, x::AbstractIrrational; tol::Real=0) where T
     return rationalize(T, big(x), tol=tol)
@@ -151,13 +162,20 @@ hash(x::Irrational, h::UInt) = 3*objectid(x) - h
 
 widen(::Type{T}) where {T<:Irrational} = T
 
-zero(::AbstractIrrational) = false
-zero(::Type{<:AbstractIrrational}) = false
+zero(::AbstractIrrational) = zero(TypeDomainInteger)
+zero(::Type{<:AbstractIrrational}) = zero(TypeDomainInteger)
 
-one(::AbstractIrrational) = true
-one(::Type{<:AbstractIrrational}) = true
+one(::AbstractIrrational) = one(TypeDomainInteger)
+one(::Type{<:AbstractIrrational}) = one(TypeDomainInteger)
 
-sign(x::AbstractIrrational) = ifelse(x < zero(x), -1.0, 1.0)
+function sign(x::AbstractIrrational)
+    o = one(TypeDomainInteger)
+    if signbit(x)
+        -o
+    else
+        o
+    end
+end
 
 -(x::AbstractIrrational) = -Float64(x)
 for op in Symbol[:+, :-, :*, :/, :^]

base/math.jl

@@ -29,6 +29,8 @@ using Core.Intrinsics: sqrt_llvm
 
 using .Base: IEEEFloat
 
+using ..TypeDomainIntegers
+
 @noinline function throw_complex_domainerror(f::Symbol, x)
     throw(DomainError(x,
         LazyString(f," was called with a negative real argument but will only return a complex result if called with a complex argument. Try ", f,"(Complex(x)).")))
@@ -262,6 +264,13 @@ deg2rad(z::Real) = deg2rad(float(z))
 rad2deg(z::Number) = (z/pi)*180
 deg2rad(z::Number) = (z*pi)/180
 
+function deg2rad(@nospecialize z::typeof(zero(TypeDomainInteger)))
+    z
+end
+function rad2deg(@nospecialize z::typeof(zero(TypeDomainInteger)))
+    z
+end
+
 log(b::T, x::T) where {T<:Number} = log(x)/log(b)
 
 """
@@ -679,6 +688,16 @@ Return the fourth root of `x` by applying `sqrt` twice successively.
 """
 fourthroot(x::Number) = sqrt(sqrt(x))
 
+function sqrt(@nospecialize n::Union{typeof(NonnegativeInteger(0)),typeof(NonnegativeInteger(1))})
+    n
+end
+function cbrt(@nospecialize n::Union{typeof(NonnegativeInteger(0)),typeof(NonnegativeInteger(1))})
+    n
+end
+function fourthroot(@nospecialize n::Union{typeof(NonnegativeInteger(0)),typeof(NonnegativeInteger(1))})
+    n
+end
+
 """
     hypot(x, y)
 
@@ -823,6 +842,8 @@ function _hypot(x::NTuple{N,<:IEEEFloat}) where {N}
     return scale * sqrt(mapreduce(y -> abs2(y * invscale), add_fast, x))
 end
 
+hypot(x::TypeDomainInteger) = abs(x)
+
 atan(y::Real, x::Real) = atan(promote(float(y),float(x))...)
 atan(y::T, x::T) where {T<:AbstractFloat} = Base.no_op_err("atan", T)
 
@@ -1594,4 +1615,74 @@ exp2(x::AbstractFloat) = 2^x
 exp10(x::AbstractFloat) = 10^x
 fourthroot(::Missing) = missing
 
+function exp2(@nospecialize n::Union{
+    typeof(NonnegativeInteger(0)),
+    typeof(NonnegativeInteger(1)),
+})
+    natural_successor(n)
+end
+function exp10(n::typeof(NonnegativeInteger(0)))
+    natural_successor(n)
+end
+function expm1(n::typeof(NonnegativeInteger(0)))
+    n
+end
+
+function sinh(n::typeof(NonnegativeInteger(0)))
+    n
+end
+function cosh(n::typeof(NonnegativeInteger(0)))
+    natural_successor(n)
+end
+function tanh(n::typeof(NonnegativeInteger(0)))
+    n
+end
+function sech(n::typeof(NonnegativeInteger(0)))
+    natural_successor(n)
+end
+function asinh(n::typeof(NonnegativeInteger(0)))
+    n
+end
+function acosh(n::typeof(NonnegativeInteger(1)))
+    natural_predecessor(n)
+end
+function atanh(n::typeof(NonnegativeInteger(0)))
+    n
+end
+function asech(n::typeof(NonnegativeInteger(1)))
+    natural_predecessor(n)
+end
+
+function log2(@nospecialize n::Union{typeof(NonnegativeInteger(1)),typeof(NonnegativeInteger(2))})
+    natural_predecessor(n)
+end
+function log10(@nospecialize n::typeof(NonnegativeInteger(1)))
+    zero(NonnegativeInteger)
+end
+function log(@nospecialize n::typeof(NonnegativeInteger(1)))
+    zero(NonnegativeInteger)
+end
+function log1p(@nospecialize n::typeof(NonnegativeInteger(0)))
+    zero(NonnegativeInteger)
+end
+
+function sind(n::typeof(NonnegativeInteger(0)))
+    n
+end
+function asind(n::typeof(NonnegativeInteger(0)))
+    n
+end
+function cosd(n::typeof(NonnegativeInteger(0)))
+    natural_successor(n)
+end
+function acosd(n::typeof(NonnegativeInteger(1)))
+    natural_predecessor(n)
+end
+function secd(n::typeof(NonnegativeInteger(0)))
+    natural_successor(n)
+end
+function asecd(n::typeof(NonnegativeInteger(1)))
+    natural_predecessor(n)
+end
+
 end # module

base/mathconstants.jl

@@ -8,6 +8,8 @@ See [`π`](@ref), [`ℯ`](@ref), [`γ`](@ref), [`φ`](@ref) and [`catalan`](@ref
 """
 module MathConstants
 
+using ..TypeDomainIntegers
+
 export π, pi, ℯ, e, γ, eulergamma, catalan, φ, golden
 
 Base.@irrational π        pi
@@ -120,13 +122,13 @@ for T in (AbstractIrrational, Rational, Integer, Number, Complex)
 end
 Base.literal_pow(::typeof(^), ::Irrational{:ℯ}, ::Val{p}) where {p} = exp(p)
 
-Base.log(::Irrational{:ℯ}) = 1 # use 1 to correctly promote expressions like log(x)/log(ℯ)
+Base.log(::Irrational{:ℯ}) = one(TypeDomainInteger)
 Base.log(::Irrational{:ℯ}, x::Number) = log(x)
 
-Base.sin(::Irrational{:π}) = 0.0
-Base.cos(::Irrational{:π}) = -1.0
-Base.sincos(::Irrational{:π}) = (0.0, -1.0)
-Base.tan(::Irrational{:π}) = 0.0
+Base.sin(::Irrational{:π}) = zero(TypeDomainInteger)
+Base.cos(::Irrational{:π}) = -one(TypeDomainInteger)
+Base.sincos(::Irrational{:π}) = (zero(TypeDomainInteger), -one(TypeDomainInteger))
+Base.tan(::Irrational{:π}) = zero(TypeDomainInteger)
 Base.cot(::Irrational{:π}) = -1/0
 
 end # module

base/mpfr.jl

@@ -22,7 +22,7 @@ import
         RawBigIntRoundingIncrementHelper, truncated, RawBigInt
 
 
-using .Base.Libc
+using .Base.Libc, ..TypeDomainIntegers
 import ..Rounding:
     rounding_raw, setrounding_raw, rounds_to_nearest, rounds_away_from_zero,
     tie_breaker_is_to_even, correct_rounding_requires_increment
@@ -402,6 +402,22 @@ function Bool(x::BigFloat)
     isone(x) && return true
     throw(InexactError(:Bool, Bool, x))
 end
+function convert(::Type{NonnegativeInteger}, x::BigFloat)
+    isinteger(x) || throw(InexactError(:NonnegativeInteger, NonnegativeInteger, x))
+    TypeDomainIntegers.Conversion.tdnn_from_x(x)
+end
+function convert(::Type{TypeDomainInteger}, x::BigFloat)
+    isinteger(x) || throw(InexactError(:TypeDomainInteger, TypeDomainInteger, x))
+    TypeDomainIntegers.Conversion.tdi_from_x(x)
+end
+function NonnegativeInteger(x::BigFloat)
+    isinteger(x) || throw(InexactError(:NonnegativeInteger, NonnegativeInteger, x))
+    TypeDomainIntegers.Conversion.tdnn_from_x(x)
+end
+function TypeDomainInteger(x::BigFloat)
+    isinteger(x) || throw(InexactError(:TypeDomainInteger, TypeDomainInteger, x))
+    TypeDomainIntegers.Conversion.tdi_from_x(x)
+end
 function BigInt(x::BigFloat)
     isinteger(x) || throw(InexactError(:BigInt, BigInt, x))
     trunc(BigInt, x)
@@ -951,6 +967,17 @@ cmp(x::CdoubleMax, y::BigFloat) = -cmp(y,x)
 <=(x::BigFloat, y::CdoubleMax) = !isnan(x) && !isnan(y) && cmp(x,y) <= 0
 <=(x::CdoubleMax, y::BigFloat) = !isnan(x) && !isnan(y) && cmp(y,x) >= 0
 
+for func ∈ (:+, :-, :*, :(==))
+    @eval begin
+        function Base.$func((@nospecialize l::BigFloat), (@nospecialize r::TypeDomainInteger))
+            TypeDomainIntegers.BaseHelpers.apply_n_t($func, l, r)
+        end
+        function Base.$func((@nospecialize l::TypeDomainInteger), (@nospecialize r::BigFloat))
+            TypeDomainIntegers.BaseHelpers.apply_t_n($func, l, r)
+        end
+    end
+end
+
 # Note: this inlines the implementation of `mpfr_signbit` to avoid a
 # `ccall`.
 signbit(x::BigFloat) = signbit(x.sign)

base/rational.jl

@@ -310,7 +310,7 @@ julia> denominator(4)
 1
 ```
 """
-denominator(x::Integer) = one(x)
+denominator(@nospecialize x::Integer) = one(TypeDomainInteger)
 denominator(x::Rational) = x.den
 
 sign(x::Rational) = oftype(x, sign(x.num))