Cannot multiply `Rational{Integer}` and `Float64`

[AayushSabharwal]

MWE:

julia> Rational{Integer}(4//3) * 5.2
ERROR: promotion of types Rational{Integer} and Float64 failed to change any arguments
Stacktrace:
 [1] error(::String, ::String, ::String)
   @ Base ./error.jl:44
 [2] sametype_error(input::Tuple{Rational{Integer}, Float64})
   @ Base ./promotion.jl:424
 [3] not_sametype(x::Tuple{Rational{Integer}, Float64}, y::Tuple{Rational{Integer}, Float64})
   @ Base ./promotion.jl:418
 [4] promote
   @ ./promotion.jl:401 [inlined]
 [5] *(x::Rational{Integer}, y::Float64)
   @ Base ./promotion.jl:430
 [6] top-level scope
   @ REPL[34]:1

Which seems to indicate a missing promotion rule. I'd expect this to promote to Float64.

[jishnub]

Perhaps you were looking at Int instead of Integer? Since the latter is an abstract type, it's not going to be promoted to a concrete float type.

[AayushSabharwal]

This is reduced from a much larger error in SymbolicUtils, the choice of Rational{Integer} is intentional. I understand why promote_type(Integer, Float64) returns Real, but Rational{Integer} is not an abstract type. As far as I am aware, multiplying any Rational by any floating point number returns a floating point number so I don't see why that shouldn't be reflected here.

[adienes]

a "floating point number" yes, but which one?

julia> (big(1//6) * 1.5) |> typeof
BigFloat

in some sense the original example "should" promote to AbstractFloat, but it is not possible to return a value with that type (since it is not a concrete type). IMO I don't really know how this could be changed (although I recognize that it is annoying for your use case)

[AayushSabharwal]

Interesting, I wasn't aware of that interaction. Could this be phrased as promote_type(promote_type(rat.num, rat.den), Float64) where rat::Rational{Integer}?

[martinholters]

in some sense the original example "should" promote to AbstractFloat

Maybe it should indeed?

julia> Base.promote_rule(::Type{Rational{Integer}}, ::Type{Float64}) = AbstractFloat

julia> Rational{Integer}(4//3) * 5.2
6.933333333333334

julia> Rational{Integer}(big(4//3)) * 5.2
6.933333333333333570180911920033395290374755859375

Right now, the promotion hits

julia/base/rational.jl

Line 189 in 5741911

promote_rule(::Type{Rational{T}}, ::Type{S}) where {T<:Integer,S<:AbstractFloat} = promote_type(T,S)

and

julia> promote_type(Integer, Float64)
Real

is too broad. (Maybe that should give AbstractFloat?)

[JeffBezanson]

That's a good idea. Generally the multiplication should work regardless of that promotion rule; for example we could add a method for *(x::Rational, y::AbstractFloat) instead, but that would probably require adding more methods.