Fix promote_operation for irrational numbers (#165)

* Fix promote_operation for irrational numbers

* Fixes

* Support user-defined `Irrational` in `promote_operation` (#166)

* Update `promote_operation` for `Irrational`

* Add test for `promote_operation` with user-defined `Irrational` input

* Format

* Make `_instantiate(::Type{Irrational{S}})` return corresponding value

Co-authored-by: Bowen S. Zhu <[email protected]>

Author: blegat

src/interface.jl

@@ -25,12 +25,20 @@ function promote_operation_fallback(
     )
 end
 
+_instantiate_zero(::Type{S}) where {S} = zero(S)
+_instantiate_oneunit(::Type{S}) where {S} = oneunit(S)
+
+# this is valid because Irrational numbers are defined in global scope as const
+_instantiate(::Type{S}) where {S<:Irrational} = S()
+_instantiate_zero(::Type{S}) where {S<:AbstractIrrational} = _instantiate(S)
+_instantiate_oneunit(::Type{S}) where {S<:AbstractIrrational} = _instantiate(S)
+
 function promote_operation_fallback(
     ::typeof(/),
     ::Type{S},
     ::Type{T},
 ) where {S,T}
-    return typeof(zero(S) / oneunit(T))
+    return typeof(_instantiate_zero(S) / _instantiate_oneunit(T))
 end
 
 # Julia v1.0.x has trouble with inference with the `Vararg` method, see
@@ -40,14 +48,14 @@ function promote_operation_fallback(
     ::Type{S},
     ::Type{T},
 ) where {F<:Function,S,T}
-    return typeof(op(zero(S), zero(T)))
+    return typeof(op(_instantiate_zero(S), _instantiate_zero(T)))
 end
 
 function promote_operation_fallback(
     op::F,
     args::Vararg{Type,N},
 ) where {F<:Function,N}
-    return typeof(op(zero.(args)...))
+    return typeof(op(_instantiate_zero.(args)...))
 end
 
 promote_operation_fallback(::typeof(*), ::Type{T}) where {T} = T

test/interface.jl

@@ -27,10 +27,36 @@ function MA.promote_operation(
 end
 MA.mutability(::Type{DummyMutable}) = MA.IsMutable()
 
+# Theodorus' constant √3 (deined in global scope due to const)
+Base.@irrational theodorus 1.73205080756887729353 sqrt(big(3))
 @testset "promote_operation" begin
     @test MA.promote_operation(/, Rational{Int}, Rational{Int}) == Rational{Int}
     @test MA.promote_operation(-, DummyMutable, DummyMutable) == DummyMutable
     @test MA.promote_operation(/, DummyMutable, DummyMutable) == DummyMutable
+    @testset "Issue #164" begin
+        iπ() = MA.promote_operation(+, Int, typeof(π))
+        @test iπ() == Float64
+        alloc_test(iπ, 0)
+        ℯbf() = MA.promote_operation(+, typeof(ℯ), BigFloat)
+        @test ℯbf() == BigFloat
+        # TODO this allocates as it creates the `BigFloat`
+        #alloc_test(ℯbf, 0)
+        bγ() = MA.promote_operation(/, Bool, typeof(Base.MathConstants.γ))
+        @test bγ() == Float64
+        alloc_test(bγ, 0)
+        φf32() = MA.promote_operation(*, typeof(Base.MathConstants.φ), Float32)
+        @test φf32() == Float32
+        alloc_test(φf32, 0)
+        # test user-defined Irrational
+        i_theodorus() = MA.promote_operation(+, Int, typeof(theodorus))
+        @test i_theodorus() == Float64
+        alloc_test(i_theodorus, 0)
+        # test _instantiate(::Type{S}) where {S<:Irrational} return value
+        @test MA._instantiate(typeof(π)) == π
+        @test MA._instantiate(typeof(MathConstants.catalan)) ==
+              MathConstants.catalan
+        @test MA._instantiate(typeof(theodorus)) == theodorus
+    end
 end
 
 @testset "Errors" begin